Quais são alguns dos programas e equações famosos de uma ou duas linhas? [fechadas]

Estou experimentando uma nova plataforma e estou tentando escrever um programa que lida com seqüências de caracteres com mais de 60 caracteres e gostaria de preencher o armazenamento de dados com alguns pequenos pedaços de código famosos e conhecidos e equações, já que programação e matemática combinam com o tema do meu software. O código pode estar em qualquer idioma e nas equações de qualquer disciplina da matemática, desde que tenham menos de um total de 60 caracteres. Eu suspeito que as pessoas vão começar uma foda cerebral por este.

Por exemplo,

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

60 caracteres exatamente!

Muito obrigado pela sua sabedoria!

A rotina clássica de cópia da cadeia C é conhecida por cada vez menos pessoas nesses dias:

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

não uma linha, mas apresento o último bug do mundo C:

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

Vejo o jogo da vida de Conway na APL flutuando bastante:

Um bônus extra é que isso garantirá que você esteja manipulando o unicode corretamente.

Uma versão modificada de um famoso liner Perl:

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

Essa expressão regular corresponde a strings cujo comprimento é primo.

A versão original é:

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

que corresponde a cadeias que consistem em um número primo de 1s.

Ordenação rápida:

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

Se a lista estiver vazia, o resultado classificado será a lista vazia.

Se a lista começar com o elemento xo restante da lista for xs, o resultado classificado será a lista composta pela lista classificada com todos os elementos em xs menores que x concatenados com o elemento x concatenado com a lista classificada de todos elementos em xs maiores que x.

(ou em outras palavras - divida em duas pilhas, todas menores que x e maiores que x, classifique as duas e crie uma lista com a pilha menor que, o elemento x e a pilha maior que).

Supera a compreensibilidade da versão C com bastante facilidade.

1. A função Ackerman . A implementação da versão Ackermann-Péter deve caber em 60 caracteres :)

2. Esta adorável constante hexadecimal: 0x5f3759df. É o coração do código WTFing mais que eu já vi: a raiz quadrada inversa rápida .

3. A famosa troca XOR .

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

Quando descobri o bash forkbomb, achei muito legal.

:(){ :|:& };:

print "hello world\n";

e suas derivações parecem populares. :-)

Como você menciona equações, essa pertence à sua lista:

e^{i\pi}+1=0

( Wolfram Alpha renderização : )

Como detectar números pares:

x % 2 == 0

import this em Python.

EDITAR como os comentários não podem conter quebras de linha: para aqueles sem um interpretador Python à mão, esta é a saída

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!

Não são exatamente 2 linhas, mas eu diria que isso é bastante famoso:

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

Na verdade, alguns idiomas podem descrevê-lo em uma linha. Lua vem à mente, mas há mais.

x, y = y, x

Meu exemplo de cálculo lambda favorito é o combinador Y:

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

De um exercício de K&R, aqui está uma função que retornará quantos bits estão definidos no número fornecido. Com 58 caracteres:

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

Leva um tempo proporcional ao número de bits definido. A parte "ah ha" aqui é que

n = n & (n - 1)

Remove o bit definido à direita de n.

Triângulo de Pascal recursivo em uma linha (Haskell)

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

Cinqüenta e dois caracteres, adicione espaços a gosto. Cortesia de "Ephemient" no comentário aqui .

Eu pensei que este era um exemplo melhor do que as soluções enigmáticas, mas breves, em J e K (embora ainda não seja usuário de Haskell).

Roleta Unix (PERIGO!)

Cortesia da resposta de Bigown no tópico da piada (e no comentário):

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

(Possui 62 caracteres, para que você possa remover o comentário (funcionaria dessa maneira?) Ou alguns espaços não essenciais.)

Sequência infinita de Fibonacci (Haskell)

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

DO 10 I=1.3

Este é um dos bugs mais caros da história. Essa instrução Fortran atribui o valor flutuante de 1,3 à variável denominadaDO10I .

O código correto - o cabeçalho do loop que repete as instruções até que a instrução rotule 10 e a variável do loop que Iaceite os valores 1, 2, 3:

DO 10 I=1,3

Dispositivo de 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 desenrolou uma gravação de porta mapeada em memória em uma das construções C mais bizarras que o mundo já viu.

Tudo a ver com o Hello World vem à mente. Você pode optar por variações diferentes se planejar armazenar vários idiomas.

Para algo mais não trivial, há Fibbonacci .

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

A linha acima de partições de código Scala people(uma lista de Persons) em duas listas com base em suas respectivas idades.

É necessário muito código para fazer a mesma coisa em 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);
  }
}

Trocar os valores de duas variáveis ​​sem usar uma terceira variável. Esta é uma das primeiras coisas na programação que me disseram e pensei "Hmm ... isso é legal"

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

Magia negra de John Carmack

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;
}

O maior número que pode ser representado por 8 bytes (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. Operador condicional :

   minVal = (a <b)? a: b;

2. Switch case

3. para cada loop [Java]

Este Quine do arquivo Jargon em C:

char * f = "char * f =% c% s% c; main () {printf (f, 34, f, 34,10);}% c"; main () {printf (f, 34, f, 34,10);}

Também existe uma versão LISP, mas você pode encontrar muitas outras por aí, em praticamente qualquer idioma que possa imaginar ...

identidade de euler que liga os números mais bonitos do universo matemático: 1, 0, e, ie π: e ^ i (π) + 1 = 0

Eu tive um bom e escrevi na margem.

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

Provavelmente não é famoso, mas um dos meus favoritos. Para a maioria, não é imediatamente aparente por que funciona.

Isso tem um pouco mais de 60 caracteres, mas realmente depende da nomeação de variáveis ​​(por isso estou incluindo!)

deixe readLines (rdr: StreamReader) =
      seq {enquanto não rdr.EndOfStream
                produz rdr.ReadLine ()}

Pequena função agradável para ler um arquivo em uma sequência linha por linha em F #.