¿Cuáles son algunos de los famosos programas y ecuaciones de una o dos líneas? [cerrado]

Estoy experimentando con una nueva plataforma y estoy tratando de escribir un programa que trate con cadenas que no tengan más de 60 caracteres y me gustaría llenar el almacén de datos con algunos pequeños fragmentos de código famosos o conocidos y ecuaciones, ya que la programación y las matemáticas van junto con el tema de mi software. El código puede estar en cualquier idioma y las ecuaciones de cualquier disciplina matemática, siempre que tengan menos de 60 caracteres de longitud. Sospecho que la gente va a romper un poco de cerebro por este.

Por ejemplo,

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

¡60 caracteres exactamente!

¡Muchas gracias por tu sabiduría!

La rutina clásica de copia de cadenas en C es conocida por cada vez menos personas estos días:

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

no una línea, pero presento The Last C C Bug del mundo:

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

Veo el juego de la vida de Conway en APL flotando mucho:

Una ventaja adicional es que esto asegurará que esté manejando Unicode correctamente.

Una versión modificada de un famoso Perl one-liner:

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

Esta expresión regular coincide con cadenas cuya longitud es primo.

La versión original es:

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

que coincide con cadenas que consisten en un número primo de 1s.

Ordenación rápida:

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

Si la lista está vacía, el resultado ordenado es la lista vacía.

Si la lista comienza con el elemento x, y el resto de la lista es xs, entonces el resultado ordenado es una lista que consiste en la lista ordenada que consiste en todos los elementos en xs menos que x concatenados con el elemento x concatenado con la lista ordenada de todos elementos en xs mayores que x.

(o, en otras palabras, divídalos en dos pilas, todas menores que xy todas mayores que x, ordénelas y cree una lista con la pila menor que, el elemento xy la pila mayor que).

Supera la comprensibilidad de la versión C con bastante facilidad.

1. La función de Ackerman . La implementación de la versión Ackermann-Péter debe caber en 60 caracteres :)

2. Esta encantadora constante hexadecimal: 0x5f3759df. Es el corazón del código más WTFing que he visto: la raíz cuadrada inversa rápida .

3. El famoso intercambio XOR .

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

Cuando descubrí por primera vez el bash forkbomb, pensé que era realmente dulce.

:(){ :|:& };:

print "hello world\n";

y sus derivaciones parecen ser populares. :-)

Como mencionas ecuaciones, esta pertenece a tu lista:

e^{i\pi}+1=0

( Wolfram Alpha renderizado : )

Cómo detectar números pares:

x % 2 == 0

import this en Python

EDITAR ya que los comentarios no pueden contener saltos de línea: para aquellos sin un intérprete de Python a mano, esta es la salida

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!

No son exactamente 2 líneas, pero diría que esto es bastante famoso:

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

En realidad, algunos idiomas pueden describirlo en una línea. Lua viene a mi mente pero hay más.

x, y = y, x

Mi ejemplo favorito de cálculo lambda es el combinador Y:

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

De un ejercicio en K&R, aquí hay una función que devolverá cuántos bits se establecen en el número dado. A los 58 caracteres:

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

Lleva tiempo proporcional al número de bits establecido. La parte de "ah ja" aquí es que

n = n & (n - 1)

Elimina el bit de ajuste más a la derecha de n .

Triángulo recursivo de Pascal en una línea (Haskell)

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

Cincuenta y dos personajes, agregan espacios al gusto. Cortesía de "Ephemient" en el comentario. aquí .

Pensé que este era un mejor ejemplo que las soluciones crípticas pero breves en J y K (aunque todavía no soy un usuario de Haskell).

Ruleta Unix (¡PELIGRO!)

Cortesía de la respuesta de Bigown en el hilo de broma (y el comentario):

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

(Tiene 62 caracteres de longitud, por lo que puede eliminar el comentario (¿funcionaría de esa manera?) O algunos espacios no esenciales).

Secuencia de Fibonacci infinita (Haskell)

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

DO 10 I=1.3

Este es uno de los errores más caros de la historia. Esta declaración de Fortran asigna el valor flotante de 1.3 a la variable nombrada DO10I.

El código correcto: el encabezado de las declaraciones repetitivas del bucle hasta que la declaración etiquetada 10 y la variable del bucle que Iacepta los 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 desenrolló una escritura de puerto mapeada en memoria en una de las construcciones en C más extrañas que el mundo haya visto.

Todo lo que tenga que ver con Hello World me viene a la mente. Podría optar por diferentes variaciones si planea almacenar varios idiomas.

Para algo más no trivial, está Fibbonacci .

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

La línea anterior de particiones de código Scala people(una lista de Persons) en dos listas basadas en sus respectivas edades.

Se necesita el siguiente código para hacer lo mismo en 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);
  }
}

Intercambiando los valores de dos variables sin usar una tercera variable. Esta es una de las primeras cosas en programación que me dijeron y pensé "Hmm ... eso es genial"

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

El número más grande que puede 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. Interruptor de caja

3. for-each loop [Java]

Este Quine del archivo de jerga en C:

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

También hay una versión LISP allí, pero puedes encontrar muchas otras flotando, en casi cualquier idioma que puedas imaginar ...

identidad de euler que une los números más bellos del universo matemático: 1, 0, e, i y π: e ^ i (π) + 1 = 0

Tuve una buena y la anoté en el margen.

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

Probablemente no famoso, pero uno de mis favoritos. Para la mayoría, no es inmediatamente evidente por qué funciona.

Esto tiene un poco más de 60 caracteres, pero realmente depende de los nombres variables (¡así que lo incluyo!)

deje que readLines (rdr: StreamReader) =
      seq {mientras que no rdr.EndOfStream
                produzca rdr.ReadLine ()}

Pequeña y agradable función para leer un archivo en una secuencia línea por línea en F #.