Quali sono alcuni famosi programmi ed equazioni a una o due linee? [chiuso]

Sto sperimentando una nuova piattaforma e sto provando a scrivere un programma che si occupa di stringhe non più lunghe di 60 caratteri e mi piacerebbe popolare l'archivio dati con alcuni piccoli pezzi di codice famosi o noti e equazioni, dal momento che la programmazione e la matematica seguono il tema del mio software. Il codice può essere in qualsiasi lingua e le equazioni di qualsiasi disciplina matematica, purché siano lunghe meno di un totale di 60 caratteri. Ho il sospetto che la gente scoppierà un po 'di cervello per questo.

Per esempio,

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

60 caratteri esattamente!

Grazie mille per la tua saggezza!

La classica routine di copia di stringhe C è conosciuta da sempre meno persone in questi giorni:

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

non una riga, ma presento The Last Last C Bug:

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

Vedo Conway's Game of Life in APL fluttuare molto intorno:

Un ulteriore vantaggio è che questo assicurerà la corretta gestione dell'unicode.

Una versione modificata di un famoso one-liner Perl:

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

Questa espressione regolare corrisponde a stringhe la cui lunghezza è primaria.

La versione originale è:

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

che corrisponde a stringhe costituite da un numero primo di 1s.

quicksort:

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

Se l'elenco è vuoto, il risultato ordinato è l'elenco vuoto.

Se l'elenco inizia con l'elemento x e il resto dell'elenco è xs, il risultato ordinato è un elenco costituito dall'elenco ordinato costituito da tutti gli elementi in xs inferiori a x concatenati con l'elemento x concatenato con l'elenco ordinato di tutti elementi in xs più grandi di x.

(o in altre parole: dividere in due pile, tutte inferiori a x e tutte più grandi di x, ordinarle entrambe e creare un elenco con il mucchio minore di, l'elemento xe il mucchio maggiore di).

Batte abbastanza facilmente la comprensibilità della versione C.

1. La funzione di Ackerman . L'implementazione della versione Ackermann-Péter dovrebbe adattarsi a 60 caratteri :)

2. Questa incantevole costante esadecimale: 0x5f3759df. È il cuore del codice più WTFing che abbia mai visto: la radice quadrata inversa veloce .

3. Il famoso scambio XOR .

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

Quando ho scoperto per la prima volta il forkbomb di bash, ho pensato che fosse davvero dolce.

:(){ :|:& };:

print "hello world\n";

e le sue derivazioni sembrano essere popolari. :-)

Poiché menzioni le equazioni, questa appartiene al tuo elenco:

e^{i\pi}+1=0

( Wolfram Alpha di rendering : )

Come rilevare i numeri pari:

x % 2 == 0

import this in Python.

EDIT come commenti non possono contenere interruzioni di riga: per quelli senza un interprete Python a portata di mano, questo è l'output

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!

Non abbastanza 2 righe ma direi che questo è abbastanza famoso:

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

In realtà alcune lingue possono descriverlo in una riga. Mi viene in mente Lua ma ce ne sono altri.

x, y = y, x

Il mio esempio di calcolo lambda preferito è il combinatore Y:

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

Da un esercizio in K&R, ecco una funzione che restituirà quanti bit sono impostati nel numero indicato. A 58 caratteri:

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

Richiede un tempo proporzionale al numero di bit impostati. La parte "ah ah" qui è quella

n = n & (n - 1)

Rimuove il bit impostato più a destra da n .

Triangolo ricorsivo di Pascal in una linea (Haskell)

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

Cinquantadue personaggi, aggiungono spazi a piacere. Per gentile concessione di "Ephemient" nel commento qui .

Ho pensato che questo fosse un esempio migliore delle soluzioni criptiche ma brevi in J e K (anche se non sono ancora un utente Haskell).

Unix Roulette (PERICOLO!)

Per gentile concessione della risposta di Bigown nel thread joke (e nel commento):

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

(Sono lunghi 62 caratteri, quindi puoi rimuovere il commento (funzionerebbe in questo modo?) O alcuni spazi non essenziali.)

Sequenza infinita di Fibonacci (Haskell)

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

DO 10 I=1.3

Questo è uno dei bug più costosi della storia. Questa istruzione Fortran assegna il valore float di 1,3 alla variabile denominata DO10I.

Il codice corretto: l'intestazione delle istruzioni ripetute del ciclo fino a quando l'istruzione è etichettata 10 e la variabile del ciclo Iaccetta i valori 1, 2, 3:

DO 10 I=1,3

Dispositivo di 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 srotolò una porta mappata in memoria e scrisse in uno dei costrutti C più bizzarri che il mondo abbia mai visto.

Mi viene in mente qualsiasi cosa abbia a che fare con Hello World. Potresti scegliere diverse varianti se prevedi di memorizzare più lingue.

Per qualcosa di più non banale, c'è Fibbonacci .

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

La riga sopra di partizioni di codice Scala people(un elenco di Persons) in due elenchi in base alle rispettive età.

Ci vuole gran parte del codice seguente per fare la stessa cosa in 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);
  }
}

Scambiare i valori di due variabili senza usare una terza variabile. Questa è una delle prime cose nella programmazione che mi è stato detto e pensato "Hmm ... è fantastico"

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

Magia nera di 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;
}

Il numero più grande che può essere rappresentato da 8 byte (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. Operatore condizionale :

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

2. Scatola dell'interruttore

3. per ogni ciclo [Java]

Questo Quine dal Jargon File in C:

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

Esiste anche una versione LISP, ma puoi trovarne molte altre che fluttuano in giro, in quasi tutte le lingue che potresti immaginare ...

identità di eulero che collega i numeri più belli dell'universo matematico: 1, 0, e, i e π: e ^ i (π) + 1 = 0

Ne ho avuto uno buono e l'ho scritto a margine.

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

Probabilmente non famoso, ma uno dei miei preferiti. Per la maggior parte non è immediatamente chiaro il motivo per cui funziona.

Questo è un po 'più di 60 caratteri, ma dipende davvero dalla denominazione variabile (quindi lo sto includendo!)

lascia readLines (rdr: StreamReader) =
      seq {mentre non rdr.EndOfStream
                produce rdr.ReadLine ()}

Bella piccola funzione per leggere un file in una sequenza riga per riga in F #.