Was sind einige berühmte Einzeiler- oder Zweizeilerprogramme und Gleichungen? [geschlossen]

Ich experimentiere mit einer neuen Plattform und versuche, ein Programm zu schreiben, das sich mit Strings befasst, die nicht länger als 60 Zeichen sind. Ich möchte den Datenspeicher mit einigen berühmten oder bekannten kleinen Codestücken und füllen Gleichungen, da Programmierung und Mathematik zum Thema meiner Software gehören. Der Code kann in einer beliebigen Sprache und mit Gleichungen aus einer beliebigen mathematischen Disziplin verfasst sein, sofern sie nicht länger als 60 Zeichen sind. Ich vermute, die Leute werden für diesen einen Brainfuck machen .

Beispielsweise,

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

Genau 60 Zeichen!

Vielen Dank für Ihre Weisheit!

Die klassische C-String-Kopierroutine ist an diesen Tagen immer weniger Menschen bekannt:

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

nicht eine Zeile, aber ich präsentiere The World's Last C Bug:

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

Ich sehe Conways Spiel des Lebens in APL viel herumschwirren:

Ein zusätzlicher Bonus ist, dass dies sicherstellt, dass Sie den Unicode korrekt handhaben.

Eine modifizierte Version eines berühmten Perl-Einzeilers:

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

Dieser reguläre Ausdruck stimmt mit Zeichenfolgen überein, deren Länge prim ist.

Die Originalversion ist:

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

das passt zu Strings, die aus einer Primzahl von 1s bestehen.

Schnelle Sorte:

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

Wenn die Liste leer ist, ist das sortierte Ergebnis die leere Liste.

Wenn die Liste mit dem Element x beginnt und der Rest der Liste xs ist, ist das sortierte Ergebnis eine Liste, die aus der sortierten Liste besteht, die aus allen Elementen in xs besteht, die kleiner als x sind, und mit dem Element x verknüpft ist, das mit der sortierten Liste aller Elemente verknüpft ist Elemente in xs größer als x.

(oder mit anderen Worten - teilen Sie in zwei Stapel, alle kleiner als x und alle größer als x, sortieren Sie beide und erstellen Sie eine Liste mit dem Stapel kleiner als, dem Element x und dem Stapel größer als).

Übertrifft die Verständlichkeit der C-Version ganz leicht.

1. Die Ackerman-Funktion . Die Implementierung der Ackermann-Péter-Version sollte in 60 Zeichen passen :)

2. Diese schöne hexadezimale Konstante: 0x5f3759df. Es ist das Herzstück des WTFing-Codes, den ich je gesehen habe: die schnelle Quadratwurzel .

3. Der berühmte XOR-Tausch .

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

Als ich die Bash-Gabelbombe zum ersten Mal herausgefunden habe, fand ich sie wirklich süß.

:(){ :|:& };:

print "hello world\n";

und seine Ableitungen scheinen populär zu sein. :-)

Da Sie Gleichungen erwähnen, gehört diese auf Ihre Liste:

e^{i\pi}+1=0

( Wolfram Alpha Rendering : )

So erkennen Sie gerade Zahlen:

x % 2 == 0

import this in Python.

BEARBEITEN, da Kommentare keine Zeilenumbrüche enthalten dürfen: Für Benutzer ohne einen handlichen Python-Interpreter ist dies die Ausgabe

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!

Nicht ganz zwei Zeilen, aber ich würde sagen, das ist ziemlich berühmt:

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

Tatsächlich können einige Sprachen es in einer Zeile beschreiben. Lua kommt in den Sinn, aber es gibt noch mehr.

x, y = y, x

Mein Lieblingsbeispiel für eine Lambda-Rechnung ist der Y-Kombinator:

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

Aus einer Übung in K & R folgt eine Funktion, die zurückgibt, wie viele Bits in der angegebenen Zahl gesetzt sind. Bei 58 Zeichen:

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

Es dauert eine Zeit, die proportional zur Anzahl der gesetzten Bits ist. Der "ah ha" Teil hier ist das

n = n & (n - 1)

Entfernt das am weitesten rechts gesetzte Bit von n.

Rekursives Pascal-Dreieck in einer Zeile (Haskell)

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

Fügen Sie zweiundfünfzig Zeichen nach Belieben Leerzeichen hinzu. Mit freundlicher Genehmigung von "Ephemient" im Kommentar hier .

Ich dachte, dies sei ein besseres Beispiel als die kryptischen, aber kurzen Lösungen in J und K (obwohl ich noch kein Haskell-Benutzer bin).

Unix Roulette (GEFAHR!)

Mit freundlicher Genehmigung von Bigowns Antwort im Scherz-Thread (und dem Kommentar):

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

(Das ist 62 Zeichen lang, sodass Sie den Kommentar (würde es so funktionieren?) Oder einige nicht wesentliche Leerzeichen entfernen können.)

Unendliche Fibonacci-Sequenz (Haskell)

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

DO 10 I=1.3

Dies ist einer der teuersten Fehler in der Geschichte. Diese Fortran-Anweisung weist der genannten Variablen den Gleitkommawert 1,3 zu DO10I.

Der richtige Code - der Header der sich wiederholenden Schleifenanweisungen bis zur Anweisung mit der Bezeichnung 10 und die Schleifenvariable, Idie die Werte 1, 2, 3 akzeptiert:

DO 10 I=1,3

Duffs Gerät :

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 entrollte einen speicherabgebildeten Port, der in eines der bizarrsten C-Konstrukte geschrieben wurde, die die Welt je gesehen hat.

Alles, was mit Hello World zu tun hat, fällt mir ein. Sie können verschiedene Varianten wählen, wenn Sie mehrere Sprachen speichern möchten.

Für etwas Nicht-Trivialeres gibt es Fibbonacci .

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

Die obige Zeile von Scala-Code-Partitionen people(eine Liste von Persons) in zwei Listen, basierend auf ihrem jeweiligen Alter.

Um das Gleiche in Java zu tun, ist der folgende Code erforderlich:

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

Tauschen Sie die Werte zweier Variablen aus, ohne eine dritte Variable zu verwenden. Dies ist eines der ersten Dinge in der Programmierung, die mir gesagt wurden und ich dachte "Hmm ... das ist cool"

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

Schwarze Magie von 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;
}

Die größte Zahl, die durch 8 Byte (Python) dargestellt werden kann

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. Bedingter Operator :

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

2. Schaltergehäuse

3. für jede Schleife [Java]

Dieses Quine aus der Jargon-Datei in C:

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

Es gibt auch eine LISP-Version, aber Sie können viele andere finden , die in so ziemlich jeder Sprache schweben, die Sie sich vorstellen können ...

eulers Identität, die die schönsten Zahlen im mathematischen Universum verknüpft: 1, 0, e, i und π: e ^ i (π) + 1 = 0

Ich hatte eine gute und schrieb sie am Rande auf.

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

Wahrscheinlich nicht berühmt, aber einer meiner Favoriten. Für die meisten ist es nicht sofort ersichtlich, warum es funktioniert.

Dies ist etwas mehr als 60 Zeichen, aber es hängt wirklich von der Benennung der Variablen ab (also schließe ich es ein!)

lies readLines (rdr: StreamReader) =
      seq {während nicht rdr.EndOfStream
                rdr.ReadLine ()} ergibt

Schöne kleine Funktion, um eine Datei Zeile für Zeile in F # in eine Sequenz einzulesen.