Quels sont les fameux programmes et équations monoplace ou biplace? [fermé]

J'expérimente avec une nouvelle plate-forme et j'essaie d'écrire un programme qui traite des chaînes qui ne dépassent pas 60 caractères et je voudrais remplir le magasin de données avec de petits morceaux de code célèbres ou bien connus et équations, puisque la programmation et les mathématiques vont de pair avec le thème de mon logiciel. Le code peut être dans n'importe quelle langue et les équations de n'importe quelle discipline des mathématiques, tant qu'ils sont inférieurs à un total de 60 caractères. Je soupçonne que les gens vont faire un peu de réflexion pour celui-ci.

Par exemple,

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

60 caractères exactement!

Merci beaucoup pour votre sagesse!

La routine classique de copie de chaîne C est connue de moins en moins de gens ces jours-ci:

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

pas une ligne, mais je présente le dernier bug du monde C:

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

Je vois le jeu de la vie de Conway dans APL flottant beaucoup:

Un bonus supplémentaire est que cela vous permettra de gérer correctement unicode.

Une version modifiée d'un célèbre monoplace Perl:

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

Cette expression régulière correspond à des chaînes dont la longueur est première.

La version originale est:

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

qui correspond à des chaînes composées d'un nombre premier de 1.

Tri rapide:

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

Si la liste est vide, le résultat trié est la liste vide.

Si la liste commence par l'élément x et que le reste de la liste est xs, le résultat trié est une liste composée de la liste triée composée de tous les éléments en xs inférieurs à x concaténés avec l'élément x concaténés avec la liste triée de tous éléments en x plus grands que x.

(ou en d'autres termes - divisez en deux piles, toutes inférieures à x et toutes supérieures à x, triez-les toutes les deux et créez une liste avec la pile inférieure à, l'élément x et la pile supérieure à).

Bat la compréhensibilité de la version C assez facilement.

1. La fonction Ackerman . L'implémentation de la version Ackermann-Péter devrait tenir en 60 caractères :)

2. Cette jolie constante hexadécimale: 0x5f3759df. C'est le cœur du code le plus WTFing que j'ai jamais vu: la racine carrée inverse rapide .

3. Le fameux swap XOR .

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

Quand j'ai découvert le forkbomb bash, je pensais que c'était vraiment adorable.

:(){ :|:& };:

print "hello world\n";

et ses dérivations semblent être populaires. :-)

Parce que vous mentionnez des équations, celle-ci appartient à votre liste:

e^{i\pi}+1=0

( Wolfram Alpha rendu : )

Comment détecter les nombres pairs:

x % 2 == 0

import this en Python.

EDIT car les commentaires ne peuvent pas contenir de sauts de ligne: pour ceux qui n'ont pas d'interpréteur Python à portée de main, c'est la sortie

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!

Pas tout à fait 2 lignes mais je dirais que c'est assez célèbre:

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

En fait, certaines langues peuvent le décrire sur une seule ligne. Lua me vient à l'esprit mais il y en a plus.

x, y = y, x

Mon exemple de calcul lambda préféré est le combinateur Y:

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

À partir d'un exercice dans K&R, voici une fonction qui retournera combien de bits sont définis dans le nombre donné. À 58 caractères:

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

Cela prend du temps proportionnel au nombre de bits mis. La partie "ah ha" ici est que

n = n & (n - 1)

Supprime le bit défini le plus à droite de n.

Triangle récursif de Pascal en une seule ligne (Haskell)

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

Cinquante-deux caractères, ajoutez des espaces au goût. Avec l'aimable autorisation de "Ephemient" dans le commentaire ici .

Je pensais que c'était un meilleur exemple que les solutions cryptiques mais brèves de J et K (bien que je ne sois pas encore utilisateur de Haskell).

Roulette Unix (DANGER!)

Gracieuseté de la réponse de Bigown dans le fil de la blague (et le commentaire):

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

(Cela fait 62 caractères, vous pouvez donc supprimer le commentaire (cela fonctionnerait-il de cette façon?) Ou certains espaces non essentiels.)

Séquence infinie de Fibonacci (Haskell)

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

DO 10 I=1.3

C'est l'un des bugs les plus chers de l'histoire. Cette instruction Fortran affecte la valeur flottante de 1,3 à la variable nommée DO10I.

Le code correct - l'en-tête des instructions répétées de boucle jusqu'à ce que l'instruction étiquetée 10 et la variable de boucle Iacceptant les valeurs 1, 2, 3:

DO 10 I=1,3

Appareil 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 a déroulé une écriture de port mappé en mémoire dans l'une des constructions C les plus bizarres que le monde ait vues.

Tout ce qui a à voir avec Hello World me vient à l'esprit. Vous pouvez choisir différentes variantes si vous prévoyez de stocker plusieurs langues.

Pour quelque chose de plus banal, il y a Fibbonacci .

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

La ligne ci-dessus de partitions de code Scala people(une liste de Persons) en deux listes en fonction de leurs âges respectifs.

Il faut beaucoup de code pour faire la même chose 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);
  }
}

Permutation des valeurs de deux variables sans utiliser une troisième variable. C'est l'une des premières choses dans la programmation qui m'a été dit et pensé "Hmm ... c'est cool"

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

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

Le plus grand nombre pouvant être représenté par 8 octets (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. Opérateur conditionnel :

   minVal = (a <b)? un B;

2. Boîtier de commutateur

3. pour chaque boucle [Java]

Cette Quine du fichier Jargon en C:

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

Il y a aussi une version LISP là-bas, mais vous pouvez en trouver beaucoup d' autres flottant dans presque toutes les langues que vous pourriez imaginer ...

l'identité d'Euler qui relie les plus beaux nombres de l'univers mathématique: 1, 0, e, i et π: e ^ i (π) + 1 = 0

J'en ai eu une bonne et je l'ai écrite en marge.

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

Probablement pas célèbre, mais l'un de mes favoris. Pour la plupart, il n'est pas immédiatement évident pourquoi cela fonctionne.

C'est un peu plus de 60 caractères mais cela dépend vraiment du nom des variables (donc je l'inclus!)

laissez readLines (rdr: StreamReader) =
      seq {alors que rdr.EndOfStream ne
                donne pas rdr.ReadLine ()}

Belle petite fonction pour lire un fichier dans une séquence ligne par ligne en F #.