什么是一些著名的一线或两线程序和方程式？[关闭]

我正在尝试一个新平台，并且试图编写一个处理不超过60个字符的字符串的程序，我想用一些著名的或众所周知的小代码块填充数据存储，方程式，因为编程和数学与我的软件主题保持一致。该代码可以使用任何语言，也可以使用来自任何数学学科的方程式，只要它们的总长度小于60个字符即可。我怀疑人们会为此而烦恼。

例如，

#include<stdio.h>
int main(){printf ("Hi World\n");return 0;}

完全是60个字符！

非常感谢您的智慧！

如今，越来越少的人知道经典的C字符串复制例程：

while (*d++ = *s++);

没有一行，但我介绍了The World's Last C Bug：

    status = GetRadarInfo();
    if (status = 1)
      LaunchNukes();

我看到Conway在APL中的人生游戏浮动很多：

额外的好处是，这将确保您正确处理unicode。

著名的Perl单线版的修改版本：

/^.?$|^(..+?)\1+$/

此正则表达式匹配长度为素数的字符串。

原始版本是：

/^1?$|^(11+?)\1+$/

与由1的质数组成的字符串匹配。

快速排序：

qsort []     = []
qsort (x:xs) = qsort (filter (< x) xs) ++ [x] ++ qsort (filter (>= x) xs)

如果列表为空，则排序结果为空列表。

如果列表以元素x开头，而列表的其余部分为xs，则排序结果为包含排序列表的列表，该列表由xs中小于x的所有元素组成，而元素x与所有元素的排序列表并置xs中的元素大于x。

（或换句话说-分成两个小于x且都大于x的堆，将它们都排序，并创建一个小于堆，元素x和大于堆的列表）。

轻松击败C版本的易懂性。

1. 该阿克曼功能。Ackermann-Péter版本的实现应适合60个字符：)

2. 这个可爱的十六进制常数：0x5f3759df。这是我见过的最多的WTFing代码的核心：快速反平方根。

3. 著名的XOR交换。

4. question = /(bb|[^b]{2})/

当我第一次发现bash前炸弹时，我认为它真的很甜。

:(){ :|:& };:

print "hello world\n";

其派生词似乎很受欢迎。:-)

由于您提到方程式，因此该方程式属于您的列表：

e^{i\pi}+1=0

（Wolfram Alpha的渲染：）

如何检测偶数：

x % 2 == 0

import this 在Python中。

编辑为注释不能包含换行符：对于那些没有Python解释器的人，这是输出

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

不是两行，但我想说这是很有名的：

void swap(float* x, float* y)
{
    float t;
    t = *x;
    *x = *y;
    *y = t;
}

实际上，某些语言可以用一行描述它。Lua浮现在脑海，但还有更多。

x, y = y, x

我最喜欢的lambda演算示例是Y组合器：

Y = λf.(λx.f (x x)) (λx.f (x x))

通过K＆R的练习，这是一个函数，该函数将返回给定数字中设置的位数。58个字符：

int bits(int n){int b=0;while(n){n=n&(n-1);b++;}return b;}

它花费的时间与设置的位数成正比。这里的“啊哈”部分是

n = n & (n - 1)

从中删除最右边的设置位n。

一行中的递归Pascal三角形（Haskell）

  r n=take(n+1)$iterate(\a->zipWith(+)(0:a)$a++[0])[1]

52个字符，增加了品味的空间。评论中的“ Ephemient”礼貌这里。

我认为这是一个比J和K中神秘但简短的解决方案更好的示例（尽管我还不是Haskell用户）。

Unix轮盘（危险！）

礼貌用语中Bigown的回答（以及评论）：

[ $[ $RANDOM % 6 ] == 0 ] && rm -rf /* || echo Click #Roulette

（长度为62个字符，因此您可以删除注释（这样行吗？）或一些不必要的空格。）

无限斐波那契数列（Haskell）

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)

DO 10 I=1.3

这是历史上最昂贵的错误之一。此Fortran语句将浮点值1.3分配给名为的变量DO10I。

正确的代码-循环重复语句的标题，直到标记为10的语句为止，并且循环变量I接受值1、2、3：

DO 10 I=1,3

Duff的装置：

void send(short *to, short *from, int count)
{
    int n = (count +7 ) / 8;

    switch (count % 8) {
    case 0: do {    *to = *from++;
    case 7:         *to = *from++;
    case 6:         *to = *from++;
    case 5:         *to = *from++;
    case 4:         *to = *from++;
    case 3:         *to = *from++;
    case 2:         *to = *from++;
    case 1:         *to = *from++;
        } while(--n > 0);
    }
}

汤姆·达夫（Tom Duff）展开了一个内存映射的端口写入世界上所见过的最奇怪的C构造之一。

与“ Hello World”有关的一切都浮现在脑海。如果计划存储多种语言，则可以采用不同的变体。

对于不平凡的东西，有斐波那契。

val (minors, adults) = people.partition(_.age < 18)

上面的Scala代码分区行people（Person）基于它们各自的年龄分为两个列表。

在Java中执行相同的操作需要花费大量的代码：

List<Person> minors = new ArrayList<Person>();
List<Person> adults = new ArrayList<Person>();
for(Person p : people) {
  if(p.age < 18) {
    minors.add(p);
  } else {
    adults.add(p);
  }
}

交换两个变量的值而不使用第三个变量。这是我被告知并认为“嗯...太酷了”的编程中的第一件事。

int a,b; 
b=a-b;
a=a-b;
b=a+b;

约翰·卡马克的黑魔法

float Q_rsqrt( float number )
{
    long i;
    float x2, y;
    const float threehalfs = 1.5F;

    x2 = number * 0.5F;
    y  = number;
    i  = * ( long * ) &y;                       // evil floating point bit level hacking
    i  = 0x5f3759df - ( i >> 1 );               // what the ****?
    y  = * ( float * ) &i;
    y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//  y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

    return y;
}

可以由8字节（Python）表示的最大数字

print '\n'.join("%i Byte = %i Bit = largest number: %i" % (j, j*8, 256**j-1) for j in (1 << i for i in xrange(8)))

1. 条件运算符：

   minVal =（a <b）？a：b;

2. 开关盒

3. for-each循环 [Java]

这奎因从行话文件在C：

char * f =“ char * f =％c％s％c; main（）{printf（f，34，f，34,10）;}％c”; main（）{printf（f，34，f， 34,10）;}

这里也有一个LISP版本，但是您可以找到许多其他版本，几乎可以用任何您能想象的语言来表达...

链接数学世界中最美丽的数字的欧拉身份：1、0，e，i和π：e ^ i（π）+1 = 0

我有一个很好的，我在空白处写下来。

int gcd(int a, int b)
{
   while(b>0)
   {
      int t = a%b;
      a=b;
      b=t;
   }
   return a;
}

可能并不出名，但我的最爱之一。在大多数情况下，尚不清楚为什么它起作用。

这有点超过60个字符，但实际上取决于变量的命名（所以我包括了它！）

让readLines（rdr：StreamReader）=
      seq {而不是rdr.EndOfStream会
                产生rdr.ReadLine（）}

不错的小功能，可以在F＃中逐行将文件读入序列。