Quels sont les fameux programmes et équations monoplace ou biplace?
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 en sortir brainfuck 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 personnes 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 doublure 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 xs supérieurs à 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.
Quand j'ai découvert le forkbomb bash, je pensais que c'était vraiment adorable.
:(){ :|:& };:
fonction Ackerman . L'implémentation de la version Ackermann-Péter devrait tenir en 60 caractères :)
Cette jolie constante hexadécimale: 0x5f3759df. C'est le cœur du code le plus WTFing que j'ai jamais vu: le racine carrée inverse rapide .
Le fameux échange XOR .
question = /(bb|[^b]{2})/
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
( rendu Wolfram Alpha : 
)
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 sans interprète Python pratique, 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!
Roulette Unix (DANGER!)
Gracieuseté de la réponse de Bigown dans le fil de 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.)
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 [~ # ~] (même si je ne suis pas encore un utilisateur de Haskell).
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 Y Combinator:
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.
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 I acceptant les valeurs 1, 2, 3:
DO 10 I=1,3
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.
val (minors, adults) = people.partition(_.age < 18)
La ligne ci-dessus de Scala partitions de code people (une liste de Persons) en deux listes en fonction de leur âge respectif.
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 de troisième variable. C'est l'une des premières choses dans la programmation à laquelle on m'a 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)))
C'est un peu plus de 60 caractères mais cela dépend vraiment du nom des variables (donc je l'inclus!)
let readLines (rdr: StreamReader) =
Seq {sans rdr.EndOfStream faire
Donne rdr.ReadLine ()}
Jolie petite fonction pour lire un fichier dans une séquence ligne par ligne en F #.
Pour une approximation bon marché, rapide et facile de la rotation autour de l'axe "x":
d = 0.0001;
y = y + z * d;
z = z - Y * d;
C'est une approximation, mais pas celle sur laquelle vous remarquerez l'erreur
Séquence infinie de Fibonacci dans Scala:
val fibs: Stream[BigInt] = 0 #:: 1 #:: { for((x, y) <- fibs.Zip(fibs.tail))
yield x + y }
Ce Quine du fichier de 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, mais vous pouvez en trouver beaucoup d'autres flottant autour, dans à peu près n'importe quelle langue 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 =
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 non trivial, il y a Fibbonacci .
Opérateur conditionnel :
minVal = (a <b)? un B;
Boîtier de commutateur
pour chaque boucle [Java]
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.
J'aime la nouvelle fonctionnalité de C # pour retourner une valeur non nulle:
var notnull = userInputName ?? "Captain NEMO";
Et leurs lambdas sont aussi très sucrés:
Func<int, int, int> addfn = (a, b) => a + b;
Func<int, int> addtwofn = (a) => addfn(a, 2);
var result = addtwofn(5); // returns 7
Pas célèbre, mais une façon hideuse de calculer la racine carrée de n, avec le résultat n.
for(double r=1;r!=n;n=r==(r=0.5*(r+(n<0?-n:n)/r))?r:n);
Et oui, la gestion des nombres négatifs est incorrecte.
Inverse d'une chaîne récursivement
if ( str.length() <= 1) { return str; // stopping case }
else { return reverse(str.substring(1)) + str.charAt(0); // recursion }