it-swarm-eu.dev

Was sind einige berühmte Einzeiler- oder Zweilinerprogramme und -gleichungen?

Ich experimentiere mit einer neuen Plattform und versuche, ein Programm zu schreiben, das sich mit Zeichenfolgen 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 in den Gleichungen aus allen mathematischen Disziplinen vorliegen, sofern diese weniger als insgesamt 60 Zeichen lang sind. Ich vermute, die Leute werden etwas ausbrechen Brainfuck für diesen.

Zum Beispiel,

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

Genau 60 Zeichen!

Vielen Dank für Ihre Weisheit!

22
BeachRunnerJoe

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

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

nicht eine Zeile, aber ich präsentiere den letzten C-Fehler der Welt:

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

Ich sehe Conways Spiel des Lebens in APL viel herumschweben:

Ein zusätzlicher Bonus ist, dass dies sicherstellt, dass Sie mit Unicode richtig umgehen.

Eine modifizierte Version eines berühmten Perl-Einzeilers:

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

Dieser reguläre Ausdruck entspricht Zeichenfolgen, deren Länge eine Primzahl ist.

Die Originalversion ist:

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

dies entspricht Zeichenfolgen, die aus einer Primzahl von 1s bestehen.

19
Barry Brown

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 sind, das mit der sortierten Liste aller 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).

Schlägt die Verständlichkeit der C-Version ganz leicht.

14
user1249

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

:(){ :|:& };:
13
Matt
  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 inverse Quadratwurzel .

  3. Der berühmte XOR-Tausch .

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

13
back2dos
print "hello world\n";

und seine Ableitungen scheinen beliebt zu sein. :-)

12
the Tin Man

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

e^{i\pi}+1=0

( Wolfram Alpha-Renderinge i pi + 1 = 0)

10
Macneil

So erkennen Sie gerade Zahlen:

x % 2 == 0
7
frogstarr78

import this in Python.


BEARBEITEN als Kommentare dürfen keine Zeilenumbrüche enthalten: Für diejenigen ohne Python Interpreter praktisch, dies ist 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!
7
MAK

Unix Roulette (GEFAHR!)

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

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

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

6
Mark C

Rekursives Pascal-Dreieck in einer Linie (Haskell)

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

Zweiundfünfzig Zeichen, fügen Sie Räume nach Geschmack 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).

6
Mark C

Nicht ganz 2 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 fällt mir ein, aber es gibt noch mehr.

x, y = y, x
6
ChaosPandion

Mein Lieblingsbeispiel für Lambda-Kalkül ist der Y-Kombinator:

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

Aus einer Übung in K & R, ist hier 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 Zeit proportional zur Anzahl der gesetzten Bits. Der "ah ha" Teil hier ist das

n = n & (n - 1)

Entfernt das am weitesten rechts gesetzte Bit aus n.

6
Macneil

nendliche Fibonacci-Sequenz (Haskell)

fibs = 0 : 1 : zipWith (+) fibs (tail fibs)
5
Kendall Hopkins
DO 10 I=1.3

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

Der richtige Code - der Header der Schleife, der Anweisungen wiederholt, bis die Anweisung mit der Bezeichnung 10 und die Schleifenvariable I die Werte 1, 2, 3 akzeptieren:

DO 10 I=1,3
4
azheglov

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 rollte einen speicherabgebildeten Port ab, der in eines der bizarrsten C-Konstrukte der Welt geschrieben wurde.

4
Jesse C. Slicer
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.

Es ist der folgende Code erforderlich, um dasselbe in Java zu tun:

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

Vertauschen der Werte zweier Variablen ohne Verwendung einer dritten Variablen. Dies ist eines der ersten Dinge in der Programmierung, die mir gesagt wurden und dachten "Hmm ... das ist cool"

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

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;
}
2
Rohan Monga

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)))
2
ykombinator

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

let readLines (rdr: StreamReader) =
Seq {während nicht rdr.EndOfStream do
Ergeben rdr.ReadLine ()}

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

1
Jetti

Für eine günstige, schnelle und einfache Annäherung der Drehung um die "x" -Achse:

d = 0.0001;
y = y + z * d;
z = z - Y * d;

Es ist eine Annäherung, aber keine, bei der Sie den Fehler jemals bemerken würden

1
Hounshell

nendliche Fibonacci-Sequenz in Scala:

val fibs: Stream[BigInt] = 0 #:: 1 #:: { for((x, y) <- fibs.Zip(fibs.tail)) 
                                           yield x + y }
1
missingfaktor

Dies 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 dort auch eine LISP-Version, aber Sie können viele andere finden, die herumschweben, in so ziemlich jeder Sprache, die Sie sich vorstellen können ...

1
grkvlt

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

1
numan

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

Für etwas nicht Triviales gibt es Fibbonacci .

1
Peach
  1. Bedingter Operator :

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

  2. Fall wechseln

  3. für jede Schleife [Java]

1
Chankey Pathak

Ich hatte eine gute und schrieb sie am Rand auf.

1
Tim
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 nicht sofort ersichtlich, warum es funktioniert.

1
Jeremiah Nunn

Ich mag die neuere Funktion von C #, um nicht null Wert zurückzugeben:

var notnull = userInputName ?? "Captain NEMO";

Und ihre Lambdas sind auch ziemlich süß:

Func<int, int, int> addfn = (a, b) => a + b;
Func<int, int> addtwofn = (a) => addfn(a, 2);
var result = addtwofn(5); // returns 7
0
Genius

Nicht berühmt, aber eine abscheuliche Methode zur Berechnung der Quadratwurzel von n, mit dem Ergebnis n.

for(double r=1;r!=n;n=r==(r=0.5*(r+(n<0?-n:n)/r))?r:n);

Und ja, die Behandlung negativer Zahlen ist falsch.

0
Anon

mkehrung eines Strings rekursiv

 if ( str.length() <= 1)  { return str; // stopping case } 
 else { return reverse(str.substring(1)) + str.charAt(0); // recursion   } 
0
pramodc84