Remarques

• Ce fil est ouvert et déverrouillé uniquement parce que la communauté a décidé de faire une exception . Veuillez ne pas utiliser cette question comme preuve que vous pouvez poser des questions similaires ici. Ne créez pas de questions supplémentaires sur la vitrine .

• Ce n'est plus un concours de popularité , ni la longueur des extraits limitée par le décompte des votes. Si vous connaissez ce fil auparavant, assurez-vous de vous familiariser avec les modifications.

Ce fil de discussion a pour objectif de présenter les fonctionnalités intéressantes, utiles, obscures et / ou uniques de vos langages de programmation préférés. Ce n'est ni un défi ni un concours, mais un effort de collaboration visant à mettre en valeur le plus grand nombre possible de langages de programmation.

Comment ça marche

• Toutes les réponses doivent inclure le nom du langage de programmation en haut de la publication, précédé du préfixe a #.

• Les réponses peuvent contenir un seul (et un seul) factoïde, c'est-à-dire quelques phrases sans code décrivant le langage.

• Outre le factoïde, les réponses doivent consister en des fragments de code, qui peuvent (mais ne doivent pas nécessairement l'être) des programmes ou des fonctions.

• Les extraits ne doivent pas nécessairement être liés. En fait, les extraits trop liés peuvent être redondants.

• Comme il ne s’agit pas d’un concours, tous les langages de programmation sont les bienvenus, quelle que soit leur création.

• Les réponses contenant plus d'une poignée d'extraits de code doivent utiliser un extrait de pile pour tout réduire, à l'exception du factoid et de l'un des extraits.

• Dans la mesure du possible, il ne devrait y avoir qu'une seule réponse par langage de programmation. Ceci est un wiki de communauté, alors n'hésitez pas à ajouter des extraits à n'importe quelle réponse, même si vous ne l'avez pas créé vous-même. Il existe un fragment de pile pour la compression des publications , ce qui devrait atténuer l’effet de la limite de 30 000 caractères.

Les réponses antérieures à ces directives doivent être modifiées. S'il vous plaît aider à les mettre à jour au besoin.

Réponses actuelles, triées alphabétiquement par nom de langue

$.ajax({type:"GET",url:"https://api.stackexchange.com/2.2/questions/44680/answers?site=codegolf&filter=withbody",success:function(data){for(var i=0;i<data.items.length;i++){var temp=document.createElement('p');temp.innerHTML = data.items[i].body.split("\n")[0];$('#list').append('<li><a href="/a/' + data.items[i].answer_id + '">' + temp.innerText || temp.textContent + '</a>');}}})

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script><base href="http://codegolf.stackexchange.com"><ul id="list"></ul>

Mathematica

Vous voudrez peut-être lire ceci de bas en haut car c'est l'ordre dans lequel il a été écrit, et certaines explications feront référence aux extraits précédents ou supposeront des explications de plus en plus basses.

La liste s'allonge assez longtemps. J'ai commencé à supprimer des extraits moins intéressants et je vais commencer à les ignorer maintenant. Consultez l' historique de révision pour obtenir une liste complète des extraits pouvant aller jusqu'à 41. Pour obtenir de véritables joyaux, consultez les extraits 81 , 64 , 44 , 23 , 19 , 12 et 8 .

Longueur 143 et 144 extraits

Enfin ... ça fait un moment que j'attends ça (et ça dure depuis aussi longtemps, alors je n'ai pas à attendre encore plus longtemps). J'ai mentionné précédemment que vous pouvez également utiliser des équations numériques et résoudre des équations différentielles. Je voulais montrer un exemple non trivial de cela.

Considérons un double pendule sur une tige (c.-à-d. Un pendule attaché à un autre). Chaque tige a une longueur unitaire et chacun des deux poids du pendule a une masse unitaire. J'ai également utilisé la gravité unitaire pour raccourcir l'équation. L'extrait de 143 caractères suivant résout les équations lagrangiennes du mouvement pour un tel système (en termes d'angles de pendules et de moments cinétiques). Une dérivation peut être trouvée dans ce PDF , bien que ce soit un exercice assez simple si vous êtes familier avec la mécanique lagrangienne.

C'est assez illisible, parce que j'ai dû beaucoup jouer au golf:

d=θ@t-φ@t;NDSolve[{#''@t==-#4#2''[t]Cos@d-##3#2'@t^2Sin@d-Sin@#@t&@@@{{θ,φ,1,.5},{φ,θ,-1,1}},θ@0==2,φ@0==1,θ'@t==φ'@t==0/.t->0},{θ,φ},{t,0,60}]

Ce qui est bien, c’est que Mathematica affiche immédiatement un graphique en miniature de ce à quoi ressemblent les solutions:

D'accord, mais c'est un peu nul. Nous voulons savoir à quoi ressemble le mouvement du pendula. Voici donc un extrait de 144 caractères, qui anime la pendule tout en traçant la trajectoire du pendule inférieur:

Graphics@{Line@{{0,0},p=θ~(h={Sin@#@#2,-Cos@#@#2}&)~t,p+φ~h~t},White,{0,0}~Circle~2.2}~Show~ParametricPlot[θ~h~u+φ~h~u,{u,0,t}]~Animate~{t,0,60}

L'animation résultante ressemble à ceci:

^{J'ai dû tricher légèrement: si vous tracez au t = 30- delà , le ParametricPlotnombre de points par défaut utilisé est trop petit et la ligne devient très irrégulière. Mais la plupart des dynamiques intéressantes se sont produites après cette période. J'ai donc utilisé l'option PlotPoints -> 200permettant de rendre la seconde moitié de l'animation plus fluide. Il n’ya rien de fondamentalement différent, et la première moitié semblerait impossible à distinguer de toute façon.}

Je pense que ce sera mon dernier extrait, à moins que je ne trouve quelque chose de vraiment époustouflant. J'espère que vous avez apprécié cela!

Longueur 100 extrait

GeoGraphics[{GeoStyling[Opacity[0.5]], NightHemisphere[]}, GeoBackground -> GeoStyling["ReliefMap"]]

Je pensais à quelques Geofonctions intéressantes pour l'extrait de code 100, mais au final, j'ai trouvé quelque chose de vraiment intéressant sur Tweet-a-Program , que je devais juste voler. Ce qui précède génère une très belle carte du soleil de la Terre pour l’heure et le jour actuels, en superposant une forme semi-opaque de l’hémisphère nocturne sur une carte en relief:

Longueur 81 extrait

CellularAutomaton[{{0,2,3,If[0<Count[#,1,2]<3,1,3]}[[#[[2,2]]+1]]&,{},{1,1}},i,n]

Je promets que c'est le dernier automate cellulaire. Mais ce droit là est Wireworld en 81 caractères. Cette fois, je n'ai pas encodé la règle dans un seul chiffre, a) parce que je pense que ce serait ridiculement énorme (je ne me suis pas soucié de le comprendre) et b) pour vous montrer un autre usage de CellularAutomaton. Cette fois, la règle est simplement spécifiée comme une fonction pure, qui reçoit un voisinage de cellules et renvoie la nouvelle valeur de la cellule. C'est une approche beaucoup plus pratique pour les automates cellulaires avec plus de 2 couleurs / états.

Quoi qu'il en soit, j'ai configuré l'exemple de Wikipedia dans i(deux horloges générant des signaux et une porte XOR) et je l'ai laissé s'exécuter pour une cinquantaine d'étapes:

Si cela vous intéresse, le tracé et l'animation réels pourraient avoir été extraits 77:

ListAnimate[ArrayPlot[#,ColorRules->{0->Black,1->Blue,2->Red,3->Yellow}]&/@w]

Longueur 69 extrait

DSolve[r^2*R''[r]+2r*R'[r]-R[r]==0&&(R[r]==1&&R'[r]==2/.r->1),R[r],r]

Retour à quelque chose d'utile. En plus des systèmes d'équations normaux, Mathematica peut également résoudre des systèmes d'équations différentielles. Ce qui précède n’est techniquement qu’une équation différentielle avec des conditions aux limites, mais vous pouvez également la fournir sous forme de système à trois équations. Semblable aux fonctions d'intégration DSolveest pour les solutions exactes alors NDSolverésoudra le système numériquement. Ce qui précède donne une solution unique

{{R[r] -> 1/2 r^(-(1/2) - Sqrt[5]/2) (1 - Sqrt[5] + r^Sqrt[5] + Sqrt[5] r^Sqrt[5])}}

qui pourrait maintenant être facilement utilisé pour d'autres calculs ou tracé.

Longueur 64 extrait

CellularAutomaton[{224,{2,{{2,2,2},{2,1,2},{2,2,2}}},{1,1}},i,n]

Je vous ai promis plus de CellularAutomatonmagie! Cet extrait calcule le jeu de la vie de Conways avec la condition initiale ipour les nétapes et vous donne le résultat pour tous les pas intermédiaires.

Quelques mots sur les paramètres: 2est le nombre d'états de cellules. {{2,2,2},{2,1,2},{2,2,2}}donne les poids pour les 9 cellules dans le voisinage 3x3. Cela garantit que la cellule elle-même se distingue de la somme des 8 voisins. {1,1}indique que la règle d'AC dépend des cellules situées à un pas dans les deux sens. Enfin, 224la règle de mise à jour proprement dite est-elle codée dans un numéro unique? Déterminer ce nombre peut être un peu délicat, mais il existe un tutoriel assez utile dans la documentation . Pour les automates plus compliqués, un seul chiffre ne suffira pas (car le nombre serait énorme). Peut-être que nous y arriverons demain! ;)

Quoi qu'il en soit, si j'insère une grille aléatoire dans iet sur 200 n, et envoie le résultat via une animation ArrayPlot, nous pouvons voir que cela fonctionne réellement:

Longueur 59 extrait

SphericalPlot3D[Re[Sin[θ]Cos[θ]Exp[2I*φ]],{θ,0,π},{φ,0,2π}]

Rappelez-vous le complot polaire de l'extrait 26? On peut faire la même chose en 3D! (En fait, il existe deux fonctions: RevolutionPlot3Dpour les polaires cylindriques et SphericalPlot3Dpour les polaires sphériques.) Comme Graphics3Dtous les tracés tridimensionnels sont automatiquement rotatifs dans Mathematica, vous n'avez donc pas à vous soucier d'un bon angle de prise de vue. Ce qui précède représente quelque chose comme une harmonique sphérique (pas tout à fait) et ressemble à ceci:

Longueur 52 extrait

Manipulate[Plot[x^2a+x*b,{x,-3,3}],{a,.1,3},{b,0,3}]

Celui-ci est assez chouette. Manipulateprend n'importe quelle expression, la paramétrise avec un tas de variables, puis te fournit un widget, dans lequel tu peux ajuster les paramètres et voir en direct comment se modifie l'expression. En tant qu'expression, vous aurez généralement une sorte d'intrigue. Ceci est particulièrement utile si vous utilisez Mathematica dans des cours pour montrer comment des familles de solutions répondent à la modification des paramètres. Ce qui précède montre comment les aet bescaladent des coefficients et le décalage: une parabole

Longueur 48 extrait

Import["http://www.google.com/doodles","Images"]

Importest une commande assez puissante. Il est utilisé à la fois pour charger des fichiers depuis un disque et depuis le Web. Il connaît pas mal de formats de fichiers différents et, pour certains d'entre eux (comme les pages HTML), il peut extraire les données immédiatement. Ce qui précède télécharge toutes les images de la page de griffonnage de Google

Longueur 45 extrait

EdgeDetect@ExampleData@{"TestImage","Splash"}

Temps pour certains traitement d'image. Mathematica contient une foule d'exemples de données, notamment des images (comme Lena), des textures, des modèles 3D et des extraits audio. Tout d'abord, nous en chargeons un:

Vous voulez détecter les arêtes? C'est un appel de fonction unique:

Longueur 44 extrait

ArrayPlot@CellularAutomaton[110,{{1},0},100]

Enfin, j'ai suffisamment de caractères à utiliser CellularAutomatonpour rendre le résultat. :) Autant que je sache, CellularAutomatonMathematica est la seule fonction liée aux autorités de certification. Mais Stephen Wolfram semble se considérer comme le numéro un des automates cellulaires, cette fonction est donc incroyablement puissante. Ce qui précède montre à peu près son utilisation la plus simple. Cela simule un automate cellulaire 1D pour 100 étapes - et renvoie en fait l'état de l'automate à chacune de ces étapes, le résultat est donc bidimensionnel. La règle est le premier paramètre, qui peut être spécifié en détail via des listes ou simplement encodé dans un seul numéro. Pour cet exemple, j'ai choisi la règle 110 , plutôt célèbre, de Turing complete . {{1},0}définit la condition initiale: un seul1devant un fond de zéros. Peut-être que je montrerai plus de fonctionnalités CellularAutomatondans le futur quand j'ai plus de caractères disponibles: cela peut simuler des CA dans des dimensions plus élevées, en utilisant des quartiers plus grands et avec plus de deux états.

ArrayPlotest un autre utilitaire de tracé agréable qui trace une liste 2D sous forme de grille de couleurs unies indiquant leur valeur. Dans le cas le plus simple, 0mappend au blanc et 1au noir. Le résultat de l'extrait est:

Longueur 43 extrait

HighlightGraph[graph,FindVertexCover@graph]

Cela fait un moment que j'ai mentionné les graphiques. Il existe de nombreux problèmes théoriques communs aux graphes intégrés à Mathematica, ainsi que de jolis outils de visualisation. Ce qui précède, pour une donnée donnée graph, trouvera une couverture de sommet minimale du graphe, puis rendra le graphe avec ces sommets mis en surbrillance. Par exemple, si graphest de PetersenGraph[7,2]retour à l'extrait 18, nous obtenons:

Longueur 42 extrait

Animate[Plot[Sin[t-x],{x,0,10}], {t,0,10}]

C'est assez simple d'animer des choses dans Mathematica (et il n'est même pas nécessaire que ce soit des images). Vous lui donnez simplement l'expression à évaluer pour chaque image et un tas de paramètres qui devraient varier d'une image à l'autre. Ce qui précède anime simplement le tracé d’une onde sinusoïdale en mouvement. L'animation ressemblera au GIF suivant:

Longueur 40 extrait

SortBy[PlanetData[#, "EscapeVelocity"]&]

SortByfait ce que vous attendez: il trie une liste en fonction des valeurs obtenues en mappant une fonction donnée sur chaque élément de la liste. Mais attendez, l'appel ci-dessus ne contient pas de liste du tout. Depuis Mathematica 10, le currying ou une application partielle de certaines fonctions est pris en charge. Ce n'est pas une fonctionnalité de langage comme dans les langages fonctionnels plus puristes, mais vient d'être implémenté manuellement pour un tas de fonctions où cela est souvent utile. Cela signifie que l'extrait de code ci-dessus renvoie une nouvelle fonction, qui ne prend qu'une liste et est ensuite triée en fonction de la fonction donnée. Cela peut être très utile si vous utiliserez plus souvent cet ordre de tri dans votre code.

Et oui, il y a une autre *Datafonction intéressante - ce qui précède va trier les noms de planète en fonction de leur vitesse de sortie .

Longueur 39 extrait

f[1]=1
f[2]=1
f[n_]:=f[n]=f[n-1]+f[n-2]

J'ai promis de rendre la fonction de Fibonacci plus efficace. Cet extrait montre à quel point la mémorisation est simple dans Mathematica. Notez que tout ce qui change est un ajout f[n]=dans la troisième ligne. Donc, quand fest appelé pour une nouvelle valeur (par exemple f[3]), alors f[3]=f[3-1]+f[3-2]sera évalué. Ceci calcule f[2]+f[1], puis l'assigne à f[3](avec =, pas avec :=!), Et renvoie finalement la valeur pour notre appel initial. L'appel de cette fonction ajoute donc une nouvelle définition à cette valeur, qui est évidemment plus spécifique que la règle générale - et sera donc utilisée pour tous les appels à venir favec cette valeur.

Rappelez-vous que l'autre fonction de Fibonacci a pris 4 secondes pour 30 valeurs? Cela nécessite 3 secondes pour 300 000 valeurs.

Longueur 37 extrait

l//.{a___,x_,b___,x_,c___}:>{a,x,b,c}

Dans le dernier extrait, j'ai mentionné des modèles. Celles-ci sont le plus souvent utilisées dans les règles , qui (entre autres choses) peuvent être utilisées pour modifier des structures qui correspondent à un certain motif. Alors regardons cet extrait.

{a___,x_,b___,x_,c___}:>{a,x,b,c}est une règle. x_avec un trait de soulignement unique est un motif qui fait référence à une seule valeur arbitraire (qui peut elle-même être une liste ou similaire). a___est un motif de séquence (voir aussi l'extrait 15), qui fait référence à une séquence de 0 ou plusieurs valeurs. Notez que j'utilise x_deux fois, ce qui signifie que ces deux parties de la liste doivent avoir la même valeur. Donc, ce modèle correspond à toute liste contenant une valeur deux fois, appelle cet élément xet appelle les trois séquences autour de ces deux éléments a, bet c. Ceci est remplacé par {a,x,b,c}- c'est-à-dire que le second xest supprimé.

//.Appliquons maintenant une règle jusqu'à ce que le motif ne corresponde plus. Ainsi, l'extrait ci-dessus supprime tous les doublons d'une liste l. Cependant, c'est un peu plus puissant que cela: //.applique la règle à tous les niveaux. Donc, si lelle contient des listes (à n'importe quelle profondeur), les doublons de ces sous-listes seront également supprimés.

Longueur 36 extrait

f[1]=1
f[2]=1
f[n_]:=f[n-1] + f[n-2]

Temps pour de nouvelles fonctionnalités linguistiques! Mathematica a quelques avantages à définir des fonctions. Pour commencer, vous pouvez fournir plusieurs définitions de fonction pour le même nom, pour différents nombres ou types d'arguments. Vous pouvez utiliser des modèles pour décrire les types d'arguments auxquels une définition s'applique. De plus, vous pouvez même ajouter des définitions pour des valeurs uniques. Mathematica choisit ensuite la définition applicable la plus spécifique pour tout appel de fonction et laisse les appels non définis non évalués. Cela permet (entre autres) d’écrire des fonctions récursives de façon beaucoup plus naturelle que d’utiliser un Ifcommutateur pour le scénario de base.

Une autre chose à noter à propos de l'extrait ci-dessus est que j'utilise à la fois =et :=. La différence est que la partie droite de =n'est évaluée qu'une fois, au moment de la définition, alors qu'elle :=est réévaluée chaque fois que l'on fait référence à la partie gauche. En fait, :=cela fonctionne même lors de l'affectation de variables, qui auront alors une valeur dynamique.

Donc, ce qui précède, bien sûr, n’est qu’une fonction de Fibonacci. Et un très inefficace à cela. Le calcul des 30 premiers chiffres prend environ 4 secondes sur ma machine. Nous verrons bientôt comment améliorer les performances sans même avoir à nous débarrasser de la définition récursive.

Longueur 35 extrait

StreamPlot[{x^2,y},{x,0,3},{y,0,3}]

Un tracé très soigné, qui génère les lignes de profil d'un champ vectoriel 2D. Ceci est similaire à un tracé vectoriel normal, en ce que chaque flèche est tangente au champ vectoriel. Cependant, les flèches ne sont pas placées sur une grille de correction, mais reliées en lignes (les lignes de courant). La signification de ces lignes est qu'elles indiquent la trajectoire d'une particule (dans un fluide, par exemple) si le champ de vecteurs était un champ de vitesse. L'entrée ci-dessus ressemble à:

Longueur 34 extrait

Solve[a*x^4+b*x^3+c*x^2+d*x==0, x]

Mathematica peut également résoudre des équations (ou systèmes d'équations, mais nous ne disposons actuellement que de tant de caractères). Le résultat sera, comme d’habitude, symbolique.

{
  {x -> 0}, 
  {x -> -(b/(3 a)) - (2^(1/3) (-b^2 + 3 a c))/(3 a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) + (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)/(3 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 + I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 - I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/(6 2^(1/3) a)}, 
  {x -> -(b/(3 a)) + ((1 - I Sqrt[3]) (-b^2 + 3 a c))/(3 2^(2/3) a (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3)) - ((1 + I Sqrt[3]) (-2 b^3 + 9 a b c - 27 a^2 d + Sqrt[4 (-b^2 + 3 a c)^3 + (-2 b^3 + 9 a b c - 27 a^2 d)^2])^(1/3))/( 6 2^(1/3) a)}
}

Notez que les solutions sont données sous forme de règles , ce que je vais probablement montrer plus en détail dans un extrait de code futur.

Longueur 33 extrait

Dynamic@EdgeDetect@CurrentImage[]

Merci à benwaffle pour cette idée. CurrentImage[]charge l'image actuelle de votre webcam. EdgeDetecttransforme une image en une image noir et blanc où les bords sont blancs et le reste est noir (voir l'extrait 45 pour un exemple). Le vrai plaisir vient avec Dynamicce qui rend l'expression mise à jour elle-même. Ainsi, le résultat de cette opération permettra de diffuser des images de votre webcam et de détecter les contours en direct.

Longueur 32 extrait

NumberLinePlot[x^2<2^x,{x,-2,5}]

Un type d'intrigue assez inhabituel. Il peut tracer un tas de choses différentes le long de la droite numérique, comme des points et des intervalles. Vous pouvez également lui donner une condition et cela vous montrera la région où cette condition est vraie:

La flèche indique que la région continue à l'infini. Les cercles blancs indiquent qu'il s'agit d'intervalles ouverts (les points finaux ne font pas partie de l'intervalle). Pour les extrémités fermées, les cercles seraient remplis.

Longueur 28 extrait

Graphics3D@{Sphere[],Cone[]}

Temps pour certains graphiques 3D. Ce qui précède restitue une sphère et un cône superposés avec des paramètres par défaut, qui ressemblent à une boule de cristal:

Dans Mathematica, vous pouvez réellement cliquer et faire glisser ce petit widget pour le faire pivoter.

Longueur 27 extrait

CountryData["ITA", "Shape"]

Plus *Data! CountryDataest assez fou. Obtenir la forme d’un pays n’est même pas la pointe de l’iceberg. Il y a tellement de données sur les pays que vous pourriez probablement écrire un livre entier sur cette fonction. Comme ... il y a FemaleLiteracyFraction. Vous pouvez également interroger ces données à différents moments. Pour une liste complète, voir la référence.

Longueur 26 extrait

PolarPlot[Sin[5θ],{θ,0,π}]

Temps pour une intrigue plus intéressante. PolarPlotest simplement un complot en coordonnées polaires. Au lieu de spécifier y pour un x donné, vous spécifiez un rayon r pour un angle donné θ:

Longueur 25 extrait

{{1,5},{2,3},{7,4}}.{8,9}

Nous avons enfin assez de caractères pour quelques mathématiques vectorielles. Ce qui précède calcule la multiplication de matrice d’une matrice 2x3 et d’un vecteur de rangée 2:

{53, 43, 92}

Longueur 23 extrait

Rotate[Rectangle, Pi/2]

Il h. Héhé. Vous pensez savoir ce que cela fait. Mais tu ne le fais pas. Rectangleen soi est juste une fonction nommée. Pour obtenir un objet représentant un rectangle, vous devez appeler cette fonction avec certains paramètres. Alors, que pensez-vous qu'il se passe lorsque vous essayez de faire la rotation Rectangle? Cette:

Longueur 22 extrait

30~ElementData~"Color"

Une autre des *Datafonctions intégrées. Oui, pour les éléments chimiques, vous n'obtenez pas seulement des éléments tels que leur numéro atomique, leur point de fusion et leur nom ... vous pouvez obtenir leur couleur à la température ambiante. Ce qui précède donne la couleur du zinc:

SlateGray

Longueur 21 extrait

Integrate[E^(-x^2),x]

Nous avons eu la différenciation il y a quelque temps. Temps d'intégration. Mathematica peut gérer des intégrales définies et indéfinies. En particulier, vous Integrateobtiendrez une solution exacte, et il peut gérer une tonne d'intégrales standard et de techniques d'intégration (pour les résultats numériques, il y a NIntegrate). Si vous connaissez votre calcul, vous aurez remarqué que l'intégrale ci-dessus gaussienne n'a pas réellement d'intégrale indéfinie sous forme fermée ... sauf si vous considérez la fonction d'erreur comme forme fermée, c'est-à-dire. Mathematica retourne:

1/2 Sqrt[π] Erf[x]

Longueur 20 extrait

"Sun"~StarData~"Age"

Retour aux données intégrées . Il doit y avoir au moins deux douzaines de *Datafonctions pour tout ce à quoi vous pouvez penser. Chacun d’eux prend un identifiant pour la chose pour laquelle vous voulez que les données, et une propriété (ou liste de propriétés) à récupérer. Ce qui précède n’est que l’un des plus courts que vous puissiez obtenir Sun, Staret Agetous étant assez courts, car j’avais hâte de montrer cette fonctionnalité.

Ah oui, et ai-je mentionné que Mathematica (depuis 9 ans) supporte les quantités avec des unités? (Plus sur cela plus tard.) Ce qui précède évalue à:

Quantity[4.57*10^9, "Years"]

qui est affiché comme

Longueur 19 extrait

MandelbrotSetPlot[]

Ouais ... fonction très utile ... Je l'utilise tout le temps. (Parfois, leur désir de supporter tout ce qui est probablement calculable peut aller un peu loin ...)

Pour sa défense, la fonction est un peu plus utile que cela: vous pouvez lui attribuer une section particulière du graphique que vous souhaitez tracer.

Longueur 18 extrait

PetersenGraph[7,2]

Depuis Mathematica 8, il comprend ce que sont les graphes. Il propose donc toutes sortes de fonctions liées à la théorie des graphes. Et ce n’était pas Mathematica s’il n'incluait pas une tonne de fonctions intégrées. Ce qui précède génère les données de graphique pour un graphique de Petersen généralisé . Il produit la structure de données réelle pouvant être manipulée, mais Mathematica affiche immédiatement ces données de graphique ... sous forme graphique:

Longueur 17 extrait

Plot[x^x,{x,0,2}]

Enfin, assez de personnages pour faire du complot. Ce qui précède n'est en réalité que l'exemple le plus simple d'un graphique à une dimension. Je promets de montrer des parcelles plus fraîches plus tard

Longueur 15 extrait

{##4,#,#2,#3}&

Cela montre deux des fonctionnalités les plus puissantes (et également utiles pour le golf). Le tout est une fonction pure non nommée , comparable à lambdas en Python ou à Procs en Ruby. Les fonctions pures se terminent simplement par un &. Cet opérateur a une priorité très faible, de sorte qu'il inclut généralement presque tout ce qui reste. Les arguments d'une fonction pure sont référencés avec #, parfois suivis d'autres choses. Le premier argument est #ou #1, le second est #2, et ainsi de suite.

L'autre caractéristique est l' Sequenceart. Ce sont fondamentalement comme des splats dans d'autres langues. Une séquence est comme une liste sans la liste qui l'entoure - il s'agit littéralement d'une séquence de valeurs pouvant être utilisée dans des listes, des arguments de fonction, etc., ##en particulier est une séquence de tous les arguments de fonction pure. ##2est une séquence de tous les arguments à partir de la seconde. Donc, si nous avons nommé la fonction ci-dessus f, et l' avons appelée comme

f[1,2,3,4,5]

Nous aurions

{4,5,1,2,3}

la fonction fait donc pivoter les arguments d'entrée de 3 éléments vers la gauche. Notez que les ##4références à 4,5qui ont été aplaties dans la liste.

Longueur 12 extrait

D[x^y^x,x,y]

Différenciation partielle. Ddifférenciera successivement la première expression par rapport à ses autres arguments, vous donnant ainsi une expression symbolique. Donc, ce qui précède est d² (x ^ y ^ x) / dxdy (où les d sont partiels), que Mathematica signale être

x^y^x (y^(-1 + x) + y^(-1 + x) Log[x] + x y^(-1 + x) Log[x] Log[y]) + 
  x^(1 + y^x) y^(-1 + x) Log[x] (y^x/x + y^x Log[x] Log[y])

Longueur 9 extrait

Exp[I*Pi]

Nous n'avons pas encore fait d'arithmétique complexe! Comme vous pouvez le constater, ce πn’était en fait qu’un alias Pi. Quoi qu’il en soit, ce qui précède renverra effectivement correctement le nombre entier -1 .

Longueur 8 extrait

Sunset[]

Ouais. Parlez de fous intégrés. Sans paramètres, vous obtenez en réalité un objet datetime du prochain coucher de soleil à votre emplacement actuel. Il prend également des paramètres pour d’autres dates, d’autres lieux, etc. Voici à quoi cela ressemble pour moi à l’heure actuelle:

Longueur 7 extrait

9!/43!!

Cet extrait montre quelques bonnes choses.

Mathematica ne comporte pas seulement un opérateur factoriel intégré !, il possède également une factorielle double !!(multipliant tous les autres nombres de nbas en bas 1). De plus, il supporte les entiers de précision arbitraire. Le 43!!sera évalué exactement, jusqu'au dernier chiffre. De plus, les nombres rationnels seront également évalués exactement. Donc, comme le numérateur et le dénominateur sont des nombres entiers, Mathematica réduira les fractions autant que possible et vous présentera ensuite:

128/198893132162463319205625

Bien sûr, vous pouvez utiliser des flottants quand vous le souhaitez, mais en général, si votre entrée ne contient pas de flottants, votre résultat sera exact.

Longueur 4 extrait

Here

Il est temps que nous commencions avec la profusion de fonctions intégrées folles de Mathematica. Ce qui précède fait ce qu’il dit sur l’étain et évalue (pour moi) GeoPosition[{51.51, -0.09}].

Longueur 3 extrait

x-x

Juste pour mettre en valeur le Factoid d’ origine : ce qui précède fonctionne même si ce xn’est pas encore défini et aboutira 0dans ce cas.

Longueur 2 extrait

3x

Multiplication par juxtaposition! S'il est clair qu'un identifiant se termine et qu'un autre commence, vous n'avez pas besoin d'un *espace ni même d'un espace pour les multiplier. Cela fonctionne avec à peu près tout, y compris les chaînes et les variables qui n'ont pas encore de valeurs. Très pratique pour le golf. ;)

Longueur 1 extrait

π

Devinez quoi, c'est Pi. Et en fait, il ne s’agit pas d’une représentation approximative à virgule flottante, mais bien de Pi - donc toutes sortes de fonctions complexes et trigonométriques dans lesquelles elle est utilisée donneront des résultats exacts s’ils sont connus.

Factoïde

Mathematica peut effectuer des manipulations symboliques. Les variables n'ont donc pas besoin de valeurs pour fonctionner avec elles.

Le fameux langage de programmation Shakespeare

Shakespeare Programming Language a été créé en 2001 par deux étudiants suédois, Karl Hasselström et Jon Åslund, et associe, comme le proclament leurs auteurs ,

l'expressivité de BASIC avec la convivialité du langage d'assemblage.

Les réponses vont de haut en bas. En outre, il est courant de me voir faire référence à des extraits de code plus anciens ou plus anciens.

( lien pour moi: éditer )

Factoïde:

Le code de Shakespeare ressemble, comme on pouvait s'y attendre, à une pièce de Shakespeare, dans laquelle les variables sont des personnages de la pièce et leur valeur change à mesure qu'elles sont "insultées" ou "louées".

Longueur 1 extrait:

I

Le code de Shakespeare est divisé en actes, et les actes eux-mêmes sont divisés en scènes, pour des causalités "directes". Définir un acte comme Act Isignifiant qu'il s'agira du premier élément du code à être exécuté, par exemple, mais pas uniquement.

Longueur 2 extrait:

as

Utilisé dans une comparaison entre deux "personnages".

Longueur 3 extrait:

day

Vous avez peut-être maintenant le sentiment que SPL est très prolixe. Et bizarre. Et vous n'avez encore rien vu. day, en SPL, vaut 1. Tous les noms "positifs" et "neutres" sont considérés comme 1, ainsi que tous les noms "négatifs" -1.

Longueur 4 extrait:

rich

C'est quoi rich? Un adjectif. Dans SPL, les adjectifs permettent de multiplier par deux la valeur du nom auquel ils sont attachés. Voir la mise en œuvre à l'extrait 14.

Longueur 5 extrait:

Act I

Mise en œuvre du premier extrait. Tous les actes peuvent recevoir un titre, tel que Act I: Hamlet must die!, puisque tout ce qui suit le chiffre romain est ignoré par l'analyseur.

Longueur 6 extrait:

better

Chaque langue a des conditions, et SPL ne fait pas exception. Sauf que, comme il s’agit d’un langage dont la syntaxe est longue (et l’ai-je mentionné pour être bizarre?), Ses instructions conditionnelles vont être longues. Demander à Ophelia de demander à Juliette, Am I better than you?c'est comme avoir la if (Ophelia > Juliet)plupart des langues "normales". Et, bien sûr, vous pouvez demander l’inverse: Am I not better than you?est l’équivalent de if (Ophelia < Juliet). Et vous pouvez déjà deviner comment il =est traduit en SPL: as good as- utilisation de l’extrait de code 2.

Cependant, good/bettern'est pas le seul moyen de faire des comparaisons dans cette langue shakesperian, vous pouvez utiliser n'importe quel adjectif. Le même principe de l'extrait 3 s'applique également ici, avec les adjectifs "positifs" ayant la valeur >, alors que les adjectifs "négatifs" ont la même signification <.

Longueur 7 extrait:

Juliet:

C'est l'invocation d'une variable. après cela, ses instructions / déclarations / ce qui suivra.

Une des limites de SPL est qu’elle ne comporte qu'un nombre limité de variables: Romeo, Juliette, Hamlet, Ophelia, MacBeth, etc. sont quelques exemples de "personnages" qui apparaîtront dans un programme Shakesperian.

Longueur 8 extrait:

[Exeunt]

[Exeunt]est placé lorsque tous les "personnages" quittent la "scène". J'espère pouvoir parler un peu plus tard de l'interaction entre les personnages. Il s'agit généralement de la dernière instruction d'un programme SPL, bien qu'il [Exeunt]ne s'agisse pas spécifiquement du "caractère" terminal du langage. Pour un autre exemple, voir l'extrait 27.

Longueur 9 extrait:

as bad as

Neuf caractères, juste pour représenter un simple =extrait d’usage 2. Ai-je déjà mentionné que SPL est étrange? Voir l'extrait 30 pour des exemples. (et oui, il y a plus d'un moyen de le sortir)

Longueur 10 extrait:

difference

Une manière élégante de représenter -, une soustraction. Vous pouvez avoir des opérations mathématiques sur SPL, même si vous aurez probablement besoin d'une journée complète pour bien faire les choses.

Factoid (depuis que j'ai réussi à atteindre dix extraits de code, faisons une pause et avons un autre factoid sur SPL)

Si vous souhaitez utiliser votre code shakesperian dans toute sa splendeur, vous trouverez ce site - je le teste toujours, car je l'ai découvert il y a cinq minutes à peine. Il existe également un moyen de le traduire en C à l'aide d' un traducteur .

Un autre site pour exécuter du code SPL est celui-ci qui fonctionne en traduisant en interne le code SPL dans un autre langage ésotérique: Oracle PL / SQL.

Longueur 11 extrait:

[Exit Romeo]

Oui! Je peux enfin parler de l'interaction entre les personnages! Pour que sa valeur change ou pour interagir avec les autres, un "personnage" doit être sur scène - entrer avec [Enter Romeo]. Si un caractère est adressé à mais n'est pas présent, il y a une erreur d'exécution et le programme s'arrête. Parce que, dans SPL, la valeur des variables est définie par le nombre de noms auxquels ils vantent - ou insultent - les autres personnages présents sur la scène. J’estime que je devrais donner un exemple pour dissiper une certaine confusion que mon explication boiteuse peut créer, mais il est peut-être préférable de retarder quelques extraits.

Longueur 12 extrait:

Remember me.

SPL est assez "basique", d'accord - mais il a des piles! Lorsque, par exemple, Roméo dit à Juliette de «se souvenir de lui», il dit en fait à son proche de placer la valeur de Roméo dans sa pile. La valeur est supprimée avec Recall your happy childhood!, ou Recall your love for me, ou, fondamentalement, toute phrase qui commence par Recall- le reste n’est qu’un drivel artistique, tel que le fragment 22.

Longueur 13 extrait

Let us return

La manière shakesperienne d’avoir un goto. Et c’est là que les actes et les scènes sont utiles. Si Roméo dit à Juliette we shall return to Act II(oui, encore une fois, il y a plusieurs façons de l'écrire), le programme passera à cette partie spécifique du code. Cela se voit également à côté des instructions conditionnelles.

Longueur 14 extrait

my little pony

Oui, c'était une série dans les années 80. Ici c'est 2*1. Pourquoi? Parce que a ponyest un nom (quelque peu) positif et littleun adjectif. Donc, en nous souvenant des extraits 3 et 4, nous avons little = "2 *"et pony = "1".

Longueur 15 extrait

Speak thy mind!

Dans un programme SPL, vous verrez ce (ou Speak your mind!, ce qui est la même chose) beaucoup . Cela génère essentiellement la valeur de chaque "caractère" en chiffre, lettre ou autre, en fonction du jeu de caractères utilisé par votre ordinateur. Il y a aussi Open your mind.cela fait presque la même chose, bien que la sortie soit sous forme numérique.

Longueur 16 extrait

You are nothing!

Lorsque quelqu'un vous le dit dans la vraie vie, vous vous sentirez déprimé. Quand Ophelia dit cela à Hamlet dans la programmation shakespearienne, Hamlet se sent inutile. Qu'est-ce que ça veut dire? Ça Hamlet = 0.

Longueur 17 extrait

Ophelia, a wench.

Dans un scénario, avant le début de la lecture, les personnages doivent être présentés. Dans la plupart des langages de programmation, les variables doivent également être déclarées avant leur utilisation. Voyant que SPL est un langage de programmation qui ressemble à un scénario, voici comment déclarer ses variables, en indiquant quelles sont celles qui apparaissent au cours du programme.

Mais que signifie "une fille"? Cela signifie-t-il qu'il s'agit d'un nom de type de données spécifique (et cool)? Eh bien ... je n'aime pas vous décevoir, mais cela ne veut rien dire: l'analyseur ignore tout ce qui se passe après la virgule, ce qui signifie que vous pouvez y mettre le drame le plus extravagant auquel vous puissiez penser.

Longueur 18 extrait

lying sorry coward

-4pour toutes les créatures terrestres. Pourquoi? Parce que 2*2*(-1) = -4.

Longueur 19 extrait

Romeo:
 Remember me.

Enfin!!! Je peux enfin sortir une instruction de syntaxe complète et correcte (bien que courte)! Voici comment utiliser l'extrait 12: vous déclarez d'abord qui parle, puis vous écrivez le "dialogue" à la ligne suivante. Normalement, seuls deux "personnages" sont sur scène pour éviter de rendre l'analyseur triste et confus. Lorsque vous avez besoin d'un autre "personnage", vous en prenez un de la scène et vous le remplacez par le nouveau.

Longueur 20 extrait

cube of thy codpiece

Je voulais développer un peu plus pour celui-ci, mais, à vrai dire, les choses que je viens de dire sont encore trop courtes pour cette longueur d'extrait. Et, alors, je vous apporte ceci, qui finit par être -1- parce que (-1) ³ = -1 (et codpieceest un nom "négatif", car ils sont inconfortables et tous). SPL comprend quelques opérations arithmétiques plus élaborées comme une exponentiation et des racines carrées.

Factoid (encore un autre, puisque nous avons franchi une nouvelle étape)

Le programme "Hello World" dans Shakesperian compte 89 lignes et plus de 2400 caractères, comme on peut le voir ici .

Longueur 21 extrait

Listen to your heart.

Dans l'extrait 15, vous avez sorti quelque chose; ici, vous entrez un numéro dans le programme. Si vous voulez saisir un caractère, vous utiliserez à la Open your mind.place. Et il va sans dire que cette valeur sera stockée dans le "caractère" auquel on s'adresse.

Longueur 22 extrait

Recall your childhood!

Cette opération permet de supprimer un entier d'une pile, comme expliqué à l'extrait 12. Lorsque, par exemple, Ophelia dit à Hamlet la phrase susmentionnée, il oblige Hamlet à prendre un entier de sa pile et à l'assumer.

Bien sûr, tant que le mot recallcommence la phrase, vous pouvez compléter le reste avec à peu près tout ce que votre esprit créatif shakesperian souhaite.

Longueur 23 extrait

Are you better than me?

Mise en œuvre de l'extrait de code 6. Lorsqu'un "personnage" pose une question de ce type à un autre, ce qu'il fait équivaut à if (x > y)un langage de programmation plus courant. Le suivi de cette instruction doit être retardé jusqu'à ce que je dispose de plus de caractères.

Longueur 24 extrait

[Enter Romeo and Juliet]

Oui, les "personnages" peuvent entrer par paires. Il n'est pas nécessaire qu'un "personnage" entre dans la scène, suivi d'un autre.

Longueur 25 extrait

remainder of the quotient

25 caractères juste pour écrire un %. 25 caractères pour avoir le reste d'une division. Et l'utiliser? Eh bien, c'est encore plus gros - voir l'extrait 75.

Longueur 26 extrait

Let us return to scene II.

La voici, une gotoen SPL, qui fonctionne comme on pourrait s’y attendre dans un langage de programmation. Une chose est: vous pouvez sauter entre les scènes dans le même acte, et entre les actes; mais vous ne pouvez pas sauter de scènes en actes différents.

Longueur 27 extrait

[Exeunt Ophelia and Hamlet]

Lorsque plusieurs "personnages" quittent la scène au lieu de Exit, et respectant la tradition théâtrale de SPL, le mot latin "Exeunt" est utilisé. Parfois, il peut être remplacé par le fragment 8.

Longueur 28 extrait

Scene I: Ophelia's flattery.

Déclarer une scène. Comme vous pouvez déjà vous y attendre si vous vous en sortez, le plus important est Scene Ile reste, le reste est un fluff artistique.

Certains compilateurs ont été créés (comme celui-ci, compilant de SPL à C, écrit en Python ) et qui renvoient au texte après la numérotation de Act / Scene. Bien que plus logique (après tout, pendant une pièce de théâtre, dire aux personnages des lignes telles que "retournons à l'acte I" peut sembler stupide), je m'en tiens à la manière originale.

Longueur 29 extrait

You pretty little warm thing!

Oui, encore une autre constante (puisque nous avons besoin de beaucoup plus de caractères pour avoir des opérations arithmétiques). Celui-ci est égal à 8, car 2*2*2*1 = 8.

Longueur 30 extrait

You are as cowardly as Hamlet!

Dire cela à Romeo, par exemple, signifie que Romeo = Hamlet. J'aime l'extrait 9.

Factoid (oui, un autre point de repère est atteint!)

Ce langage a été créé pour une affectation dans un cours d'analyse de syntaxe. Par conséquent, aucun compilateur SPL n'a été créé par les auteurs. Plus: il semble que les auteurs de SPL aient rompu leurs liens avec leur création, puisque rien ne semble avoir été modifié dans la langue depuis 2001 ...

Longueur 31 extrait

Am I as horrid as a flirt-gill?

Oui, je sais, c'est l'extrait 23 qui se répète un peu, bien que nous comparions ici le "personnage" qui parle avec un "flirt-gill" (de, si vous préférez if (Ophelia == -1)). La chose est...

Longueur 32 extrait

If so, let us return to scene I.

... je peux maintenant vous présenter le thenSPL, le lien conditionnel conditionnel et la méthode shakesperienne d'implémentation de boucles. Vous pouvez, par exemple, faire en sorte que Romeo assume la valeur 0, incrémente sa valeur tout en effectuant une autre tâche et s'arrête lorsqu'il atteint 10, en poursuivant le programme par la suite.

Longueur 33 extrait

If not, let us return to scene I.

Rappelez-vous simplement que nous pouvons plutôt passer à une autre scène si la condition testée est fausse .

Longueur 34 extrait

Open your mind! Remember yourself.

Deux instructions à la suite, yippie! Le premier lit un caractère, le second le pousse dans la pile de mémoire de l'autre personnage.

Longueur 35 extrait

Act I: Death!

Scene I: Oh, shit.

La manière appropriée de déclarer un acte et une scène. Ajoutez de la bouillie artistique avec goût.

Longueur 36 extrait

Thou art as sweet as a summer's day!

Une autre façon de dire que le "personnage" auquel on s'adresse recevra la valeur 1- parce que les jours d'été sont agréables et agréables.

Longueur 37 extrait

Art thou more cunning than the Ghost?

Ophélie poser cette question aux moyens Hamlet, la traduction à un langage de programmation moins lisible, if (Hamlet > the Ghost). C'est un extrait 23, encore une fois, mais cela vous montre qu'il n'est pas nécessaire de demander aux "personnages" s'ils sont meilleurs les uns des autres: toute autre question fonctionnera également.

Longueur 38 extrait

[Enter the Ghost, Romeo and the Ghost]

Oui, j'appelle deux fois un "personnage" - parce que je voulais que le programme me renvoie une erreur. Appeler un "personnage" déjà sur scène, ou dire à un absent de sortir, causera beaucoup de chagrin à l'analyseur / compilateur.

Longueur 39 extrait

the sum of a fat lazy pig and yourself!

L'instruction complète est plus belle que cela, je vais vous donner ça, mais ... voici notre première opération arithmétique! Qu'est-ce que tout cela signifie, en fait? Eh bien, pigest un animal sale (bien que savoureux), donc équivalent à -1, a deux adjectifs, signifiant fat lazy pigégaux 2*2*(-1) = -4. Mais qu'en est-il yourself? C'est un pronoum réflexif, pas un nom ni un adjectif. Eh bien, rappelez-vous que SPL est basé sur des dialogues entre "personnages"; ainsi, yourselffait référence à l'autre "personnage" sur scène. Donc, nous arrivons à la fin et nous découvrons que « la somme d'un cochon paresseux graisse et vous » est, en fait, -4 + x.

Longueur 40 extrait

the sum of a squirrel and a white horse.

Oui, une autre somme, mais celle-ci est plus simple que l'extrait 39. C'est simplement 1 + 2- 3, si mes calculs sont corrects.

Factoid (toujours avec moi après ces quarante extraits de duvet artistique? Vous méritez un prix.)

SPL, dans sa version 1.2.1, peut être téléchargé ici .

Longueur 41 extrait

Juliet:
 Speak thy mind!

[Exit Romeo]

Parfois, les "personnages" ne sont appelés que sur scène pour changer de valeur - ce qui, dans une vraie pièce, serait quelque chose d'assez bizarre. En tout cas, ici, Juliette fait imprimer à son bien-aimé Roméo sa valeur stockée, après quoi il quitte la scène.

Longueur 42 extrait

Speak YOUR mind! You are as bad as Hamlet!

Encore une fois deux instructions sur une ligne (on peut en avoir plusieurs, mais la longueur de l'extrait ne le permet pas encore); Ici, nous avons un "caractère" qui demande à un autre de sortir sa valeur et d'assumer la valeur de Hamlet. Déroutant? Mayhap.

Longueur 43 extrait

Am I as horrid as a half-witted flirt-gill?

Juliet demande que cela ne signifie pas qu'elle a une faible estime de soi (bien que cela puisse être dans la vie réelle); c'est simplement un autre if, comme les extraits 23 et 37. Oh, j'ai failli oublier: cela se traduit par if (Juliet == -2).

Longueur 44 extrait

You are as evil as the square root of Romeo!

Oui, les racines carrées sont mauvaises, vous ne saviez pas? Quoi qu'il en soit, cette instruction est assez simple pour comprendre ce qu'elle fait: attribue le "caractère" énoncé à la valeur de la racine carrée de la valeur stockée dans Roméo.

Longueur 45 extrait

Hamlet:
 Art thou more cunning than the Ghost?

Snippet 37 correctement écrit avec le personnage qui dit la ligne.

Longueur 46 extrait

the product of a rural town and my rich purse.

D'accord ... de toute façon, SPL est peut-être la seule langue au monde qui vous permet de multiplier les villes avec des bourses. Cela signifie (2*1)*(2*1)que, si je ne me trompe pas très bien, est égal à 4.

Longueur 47 extrait

Romeo:
 Speak your mind.

Juliet:
 Speak YOUR mind!

Je vais vous donner ça: c'est peut-être l'un des dialogues les plus bizarres de l'histoire. Mais c'est ce que vous obtenez lorsque vous choisissez une langue étrange à présenter. Roméo et Juliette se disent, en bref, de sortir leurs valeurs.

Longueur 48 extrait

You lying fatherless useless half-witted coward!

Traduire directement, 2*2*2*2*(-1). -16, droite?

Longueur 49 extrait

Scene V: Closure.

Hamlet:
 Speak your mind!

[Exeunt]

Un exemple de la façon de terminer un programme dans SPL. Vous pouvez déclarer une scène spécifiquement pour elle (bien que ce ne soit pas obligatoire), puis Hamlet demande à un autre "caractère" de générer sa valeur, puis ils quittent la scène. Et oui, ils doivent tous quitter la scène.

Longueur 50 extrait

Othello, a young squire.
Lady Macbeth, an old fart.

Plus de "caractère" présentation, avant les instructions appropriées. Comme toujours, la seule chose qui compte pour le compilateur est Othelloet Lady Macbeth, donc le reste de la ligne est à gagner ...

Encore une chose: les "personnages" ne doivent pas nécessairement être liés pour apparaître dans un programme SPL - vous pouvez donc avoir Romeo, Othello et Hamlet dans la même pièce.

Factoid (un demi-siècle de ces choses? Ouf! Après cela, je pense que je vais détester William Shakespeare ...)

Le traducteur SPL en C, mentionné il y a quelque temps et développé par les créateurs de SPL, était basé sur Flex et Bison .

Longueur 51 extrait

Othello:
 Recall your great dreams. Speak your mind!

(Tellement marre de Roméo, Juliette et Hamlet ... apportons Othello, pour changer!)

Recall, comme vous pouvez le deviner, est la clé ici. Le "personnage" qu’adresse Othello prendra une valeur de sa pile, assumera cette valeur et, ensuite, la restituera.

Longueur 52 extrait

Thou art as pretty as the sum of thyself and my dog!

Une autre somme. Bâillement. En supposant que celui-ci s'adresse à Hamlet, cela veut dire Hamlet = Hamlet + 1. Ou Hamlet += 1. Ou Hamlet++.

Longueur 53 extrait

Romeo:
 You are as vile as the sum of me and yourself!

Ah, oui, quelque chose que j'ai oublié de mentionner auparavant: les «personnages» qui parlent peuvent se nommer eux-mêmes.

Longueur 54 extrait

Juliet:
 Is the sum of Romeo and me as good as nothing?

Un autre exemple de l'extrait précédent, inclus dans une condition. Donc, ce que nous avons ici est if (Romeo + Juliet == 0).

Longueur 55 extrait

Juliet:
 You are as lovely as the sweetest reddest rose.

Donc, ici, Juliette loue le "personnage" auquel elle s'adresse (supposons que ce soit Romeo, pour l'amour de Shakespeare), déclarant qu'il / elle a 4 ans. Oui, une autre assignation de valeurs.

Longueur 56 extrait

Othello:
 You lying fatherless useless half-witted coward!

Snippet 48 correctement fait, avec un "personnage". Si vous êtes trop paresseux pour faire défiler vers le haut (comme je le serais), cela signifie que celui qui est insulté reçoit la valeur -16.

Longueur 57 extrait

Romeo:
 If not, let us return to Act I. Recall thy riches!

J'ai déjà expliqué comment les conditions fonctionnent sur SPL de manière générale; Cependant, une analyse plus en ligne est nécessaire. Nous n'avons pas elseici: par exemple, dans cet exemple, si la condition échouait, le programme reviendrait à l'acte I; mais si c'était vrai, cela continuerait à l'instruction suivante, qui est un Recall- un pop de la pile, c'est-à-dire.

Longueur 58 extrait

Romeo:
 You are as disgusting as the square root of Juliet!

Saisir l’extrait 44 et présenter comment l’instruction doit être présentée. S'il s'agissait d'un dialogue entre Roméo et Othello, nous pourrions le traduire en Java par Othello = Math.sqrt(Juliet).

Longueur 59 extrait

Othello:
 You are as vile as the sum of yourself and a toad!

OK, si Othello parle à Romeo, ce serait équivalent à Romeo+(-1); Romeo--, pour faire court. Assez basique, non? C'est SPL pour vous.

Longueur 60 extrait

Is the quotient between the Ghost and me as good as nothing?

En bref, if (The Ghost/Hamlet == 0)en supposant que le "moi" appartient à Hamlet.

Longueur 61 extrait

Thou art as handsome as the sum of yourself and my chihuahua!

Une fois que vous enlevez les couches et les couches de mots et les insultes, vous remarquerez que SPL est à la base une chose élémentaire, sans fonctions ni fonctions intéressantes. Nous avons donc des charges et des charges de fonctions arithmétiques sur le corps du programme. Donc, si celui-ci était adressé à Juliette, ce serait équivalent à Juliet++.

Longueur 62 extrait

twice the difference between a mistletoe and a oozing blister!

Oui, oui, plus d'opérations arithmétiques. En gros, ces 62 octets de SPL peuvent être traduits 2*(1-2*(-1)). Ce serait une langue de golf assez impressionnante, non? Droite.

Longueur 63 extrait

You lying stupid fatherless rotten stinking half-witted coward!

48 -16 Snippet émis, celui - ci est égale à -64: 2*2*2*2*2*2*(-1).

Longueur 64 extrait

your coward sorry little stuffed misused dusty oozing rotten sky

D'après ce que je comprends de SPL, c'est parfaitement légitime. Vous avez beaucoup d'adjectifs insultants qui procèdent à un nom "positif". Puisque les adjectifs n’ont pas de distinction particulière, qu’ils soient négatifs ou non (leur seule valeur est de multiplier par deux le nombre à leur droite), nous pouvons avoir des phrases complètement stupides comme celle-ci. Ce qui équivaut à 256. Parce que 2*2*2*2*2*2*2*2*1=256.

Longueur 65 extrait

You are nothing! You are as vile as the sum of thyself and a pig.

Hmm, tellement de haine, n'est-ce pas? Donc, ce que nous avons ici est équivalent à y=0; y=y+(-1);aurait probablement pu être "joué au golf" You are a pig!, mais heh.

Longueur 66 extrait

You are as beautiful as the difference between Juliet and thyself.

Alors, soustrayez Juliette de vous, hein? Celui-ci est assez simple à décoder:, à Romeo=Juliet-Romeo;supposer que ce soit Roméo qui se parle.

Longueur 67 extrait

Juliet:
 Am I better than you?

Romeo:
 If so, let us proceed to Act V.

Comment la plupart des conditions fonctionnent sur SPL. Vous testez l'expression et, si elle est vraie (ou non: voir l'extrait 33), vous passez à une autre partie du programme; sinon, vous passerez à la phrase suivante.

Longueur 68 extrait

The Ghost:
 You are as small as the sum of yourself and a stone wall!

Oui, oui, je deviens un peu monotone. Mais SPL est comme ça. Comme je l'ai dit un peu plus tôt, ses expressions sont un mélange d'opérations arithmétiques. Il s’agit donc d’une incrémentation supplémentaire, car stone wallc’est un "nom" neutre.

Longueur 69 extrait

Thou art as disgusting as the difference between Othello and thyself!

Au lieu d'une somme, nous avons la soustraction entre deux personnages, Othello et celui à qui l'on parle.

Longueur 70 extrait

You are as handsome as the sum of Romeo and his black lazy squirrel!

Nous revenons aux ajouts, oui - appelez-moi la formule, heh. Nous traduisons ceci en Romeo + 2*2*1.

Longueur 71 extrait

Scene I: Dialogues.

[Enter Juliet]

Othello:
 Speak your mind!

[Exit Juliet]

Une scène peut être aussi petite que celle-ci. Julietentre dans la scène, Othello lui dit de sortir sa valeur stockée, puis elle descend à nouveau.

Longueur 72 extrait

twice the difference between a mistletoe and an oozing infected blister!

Encore une opération arithmétique - parce que SPL en est criblé. Nous pouvons traduire cela en 2*(1-2*2*(-1)).

Longueur 73 extrait

You are nothing! Remember me. Recall your unhappy story! Speak your mind!

Quatre instructions à la suite?! Je suis assez fier de moi, en fait. Quoi qu'il en soit, supposons qu'il s'agit d'un dialogue entre Roméo et Juliette (et qu'il parle): cela signifie que la valeur de Juliette commence à 0; ensuite, Juliet enfoncera la valeur de Roméo dans sa pile de mémoire, la déplacera et la restituera sous sa forme entrée. Simple, non?

Longueur 74 extrait

You are as sweet as the sum of the sum of Romeo and his horse and his cat!

Oui, oui, exemple ennuyeux, je sais. Mais c'est X = (Romeo + 1) + 1.

Longueur 75 extrait

Is the remainder of the quotient between Othello and me as good as nothing?

Eh bien, c'est assez simple. Si vos compétences en décodage fonctionnent mal, cela se traduit par if (Othello % X == 0).

Longueur 76 extrait

Thou art as rich as the sum of thyself and my dog! Let us return to scene I.

Le saut du fragment 26 avec une expression devant lui. Un gotosur SPL n'est pas toujours proche d'une condition, il peut en être ainsi - et, bien sûr, ce type de résultat gotosera toujours trouvé à la fin d'un acte ou d'une scène, car les instructions qui suivent ne seront jamais compilées / exécutées. La première instruction est assez simple: x=x+1.

Longueur 77 extrait

[Exit Hamlet]

[Enter Romeo]

Juliet:
 Open your heart.

[Exit Juliet]

[Enter Hamlet]

Nous avons donc Juliette et Hamlet sur scène; mais nous avons besoin de la valeur de Roméo. Ainsi, pour épargner au compilateur un très vilain mal de tête, tout d'abord nous retirons Hamlet de la scène (bien que ce soit Juliet), nous demandons à Roméo de monter sur scène. Juliet lui donne pour instruction de numéro (voir l'explication de l'extrait 21), puis Roméo sort de la scène et Hamlet revient. Assez simple et simple.

Longueur 78 extrait

The Ghost:
 Speak thy mind.

Lady Macbeth:
 Listen to thy heart! Remember thyself.

Ainsi, The Ghost (le père décédé de Hamlet) dit à Lady Macbeth de publier sa valeur, alors qu’elle ordonne à The Ghost de lire un numéro et de le placer dans sa pile.

Piet

Factoïde

Piet est un langage de programmation où le code source est constitué d'images. Le déroulement du programme commence par le pixel en haut à gauche et se déplace dans l'image entre les pixels et les groupes de pixels jusqu'à la fin.

Pour la lisibilité, les programmes Piet sont généralement affichés dans une version agrandie. Dans un tel cas, le terme codelest utilisé pour décrire un groupe de pixels de même couleur qui correspondent à un pixel individuel dans l'image source.

Pour ce défi, comme Piet n’utilise pas de caractères, un code par vote sera utilisé pour les exemples de programmes.

1 code

C'est un programme valide, il ne fait rien et se termine. Le flux de contrôle commence dans le pixel en haut à gauche (uniquement) et n'a pas de sortie, ce qui termine le programme.

Le pixel peut dans ce cas être n'importe quelle couleur pour le même effet.

2 codels

Cela lira continuellement les caractères de stdin et conservera un total cumulé de leurs valeurs unicode (bien que rien ne soit fait avec ce total et qu'il ne soit pas affiché).

Le flux de programme va et vient entre les 2 codes, car le seul moyen de sortir de l’un est l’autre. Les commandes sont exécutées par mouvement d’un code ou d’une région à l’autre, en fonction de la différence de teinte et de légèreté des 2 régions. Le inputest la commande allant de gauche à droite, puis de adddroite à gauche. Sur la première addcommande, rien ne se passera puisqu'il n'y a qu'une seule valeur sur la pile et la spécification indique que les commandes sans suffisamment de valeurs disponibles sont ignorées.

Ce programme est une boucle qui ne finira jamais, car la plupart des programmes de piétons auront des tailles extrêmement petites, car il faut au moins quelques codes pour "attraper" correctement le flux du programme et le terminer.

3 codels

Ceci est un programme basique de type écho, il lit un caractère à la fois à partir de stdin et l’imprime sur stdout.

Encore une fois c'est une boucle infinie. Le programme commence par aller de gauche à droite, ce qui se passe inputensuite output. Le programme continuera à suivre la même direction chaque fois qu'il le pourra. Au code vert clair, la seule issue est de commencer à revenir dans le sens inverse. Lorsque vous voyagez en arrière droite à gauche , il tente d'exécuter subtractet addcommandes, mais la pile est vide si ceux - ci deviennent pas d'habitation.

4 codels

Imprime 2 sur la sortie standard indéfiniment.

Sur le plan fonctionnel, ce n'est pas un programme particulièrement intéressant, mais maintenant que nous avons enfin un nombre composite de codes, nous pouvons afficher un flux légèrement plus avancé que le flux de gauche à droite. Lorsque le flux de programme tente de sortir d'un code, il essaie d'abord la direction actuelle. Si ce n'est pas le cas (dans ce cas, en raison du bord de l'image), il pivote de 90 degrés dans le sens des aiguilles d'une montre et tente à nouveau de sortir. Dans ce cas, le programme tourne dans le sens horaire 1 code à la fois, en pushinsérant 1 sur la pile deux fois, adden regroupant les éléments ensemble, puis en outputgénérant le résultat.

5 codels

Lit de manière répétée un caractère à la fois sur stdin et suit la somme de leurs valeurs unicode.

Il s'agit essentiellement de la même fonctionnalité que la version à deux codets, mais ce défi consiste à présenter le langage. L'un des avantages du piétin est qu'il permet d'obtenir des images d'aspect différent qui font la même chose.

Nous voyons ici le code blanc pour la première fois, ce qui permet au flux de programme de glisser sans l’exécuter d’instructions. Les codes magenta et bleu font tout le travail ici. Passer du bleu au rouge ne fait rien car il traverse le code blanc au milieu. Les 2 rouges juste pushle numéro 1 sur la pile et pople reculant comme il se déplace de gauche à droite puis de droite à gauche, puis à travers le code blanc afin qu'aucune instruction ne soit exécutée.

6 codels

Encore une fois, en répétant les fonctionnalités précédentes avec un look différent. Ceci est un autre programme d'écho qui lit un caractère à la fois de stdin à stdout.

Nous voyons ici notre premier code noir. Le flux de programme ne peut pas entrer dans un code noir. Par conséquent, à partir du code magenta clair en haut à droite, le programme ne pourra pas sortir correctement en raison du bord de l'image, ne pourra pas quitter en raison du code noir et rebondira à gauche dans le code rouge. . Les codels bleus et verts sont purement décoratifs, le programme n'y entrera jamais.

7 codels

Encore un autre programme d'écho avec un look différent.

Nous voyons ici nos premiers blocs de code plus grands que la taille 1. Au piet, tout bloc contigu de codes de même couleur est traité comme un seul bloc. La taille du bloc n'a pas d'importance, sauf lors de l'exécution de l' pushinstruction. Ce programme est donc traité exactement comme la version à 3 codels, à l'exception des couleurs.

8 codels

Lit un numéro à partir de stdin et renvoie le carré sur stdout à plusieurs reprises.

Le flux de contrôle est un schéma de base dans le sens des aiguilles d'une montre, comme dans le programme à 4 codes. A partir du haut à gauche, les opérations dans l' ordre sont input, duplicate(pousse une copie supplémentaire de la valeur supérieure de la pile sur la pile) multiply, output. Ensuite, il place pushla valeur 1 sur la pile, glisse sur le blanc de sorte qu'aucune commande ne soit exécutée, puis popquitte celui-ci en dehors de la pile lors du passage du code inférieur gauche au code supérieur gauche. Cela le renvoie au début du programme avec une pile vide et il se répète.

9 Codels

Ajoute 1 + 2 = 3, puis se termine.

Maintenant que nous avons un programme avec plus de 2 codes dans les deux dimensions, nous pouvons enfin configurer une région qui va piéger le programme et le terminer au lieu de boucler indéfiniment. La première opération permettant de passer du code rouge à la région rouge foncé est un pushde 1, puis le programme tourne et descend dans le code rouge clair au milieu et pushune valeur de 2. Le passage du rouge clair au jaune clair s'exécute une addopération. La barre jaune pâle du bas provoque la fin du programme car il n’a aucun moyen de s’écouler car tous les coins sont bloqués.

Les programmes à un et deux niveaux deviennent rapidement laids et sans intérêt. À partir de ce moment, je vais me concentrer sur les chiffres qui permettent au moins quelques codes dans chaque direction.

12 codels

Enfin, un programme qui fait quelque chose qui pourrait être considéré comme utile (bien que ce soit encore un peu exagéré). Lit 2 nombres de stdin de manière séquentielle, puis affiche leur somme et le fait à plusieurs reprises.

Le programme passe de gauche à droite sur les 4 barres de couleur correspondant à 2 inputssuivies d'une addcommande. Il passe ensuite dans le code en bas à droite et effectue une opération output, puis passe à gauche dans la région blanche pour revenir au début.

Cela aurait pu être fait en 8 codels, mais comme nous disposons de l’espace supplémentaire, nous pouvons créer quelque chose qui s’inspire un peu du vieil écran de télévision sans signal.

15 codels

Lit un numéro sur stdin et affiche son carré.

Cela utilise quelques astuces pour donner un aspect symétrique à un programme qui fait réellement quelque chose. La barre rouge la plus à gauche est une couleur différente sur le code du bas, en tirant parti du fait que (pour moi au moins) ces 2 nuances de rouge se ressemblent beaucoup. le programme passera de la région rouge pâle au code bleu clair, puis tout droit au milieu du programme jusqu'au vert clair du côté droit où il est piégé. Il effectue input, duplicate, multiplyet les outputopérations.

Le code rouge plus foncé, ainsi que les codes vert moyen en haut et en bas de la colonne du milieu, sont décoratifs et le programme ne les atteindra jamais.

20 codels

Lit les nombres de stdin jusqu’à la lecture d’un 0, point auquel la somme de tous les nombres entrés est terminée.

Nous avons enfin assez de place pour contrôler le flux sous la forme de l' pointeropération. Les 4 Codels le long du sommet effectuer input, duplicateet les notopérations, puis une autre notopération de déplacement du magenta dans la partie supérieure droite de la 2-jaune codel dessous. L' notopération extrait la valeur supérieure de la pile et pousse un 1 si la valeur supérieure était un 0 et un 1 sinon. Par conséquent, un double notremplace toute valeur non nulle par un 1. Le passage de la barre jaune au bleu foncé effectue une pointeropération qui extrait la valeur supérieure de la pile et déplace le pointeur de direction autant de fois que nécessaire.

Si la valeur supérieure est un 1 (c’est-à-dire que nous n’avons pas entré de zéro), le pointeur de direction pointera vers la gauche, en se dirigeant vers les codes magenta pour une addopération (qui sera ignorée la première fois en raison d’une seule valeur sur la pile) et puis à travers le blanc retour au début du programme.

Si la valeur supérieure de la pile est égale à zéro lors de l'opération de pointeur, le pointeur de direction ne changera pas et le programme continuera à la baisse. En entrant dans la bande bleue plus claire, pople 0 entré hors pile sera laissé, ne laissant que la somme des nombres accumulés. outputCette somme sera ajoutée à la barre cyan située au bas de la barre , puis cessera puisque le flux du programme est bloqué.

25 codels

Compte à rebours! Lit un numéro à partir de stdin, puis imprime un compte à rebours de 1 à stdout un numéro à la fois. Par exemple, si 5 est lu, l’imprimante 54321 sera imprimée.

La première opération du cyan au jaune est la input. Ensuite, le jaune est l'endroit où le programme "boucle" commence. Jaune> Magenta> Le bleu est un, duplicatealors output, il imprime la valeur la plus élevée de la pile mais conserve une copie. Se déplacer sur le côté droit, nous pushla valeur 1 sur la pile puis effectuez une subtraction, ce qui diminue notre valeur entrée par 1. Vient ensuite duplicate, notet un autre notmouvement du magenta clair dans le coin inférieur droit au jaune foncé à côté. C'est la même vérification zéro / non nulle que le programme précédent. En partant à gauche dans le code bleu clair, vous effectuez une pointeropération qui consiste à déplacer le curseur dans le cyan foncé pour mettre fin au programme si nous avons terminé ou jusqu'à le jaune pour redémarrer notre boucle sans entrée initiale mais avec une valeur inférieure réduite. par 1.

Les 3 codels rouges sont décoratifs et peuvent être de n'importe quelle couleur.

30 codels

Générateur de Fibonacci. Imprime les termes de la séquence de Fibonacci sur la sortie standard et ne s’arrête pas.

C'est la première introduction de l' rollopérateur, ainsi que la première fois qu'une taille de région supérieure à 1 est utilisée avec l' pushopérateur pour obtenir une valeur spécifique sur la pile.

Comme toujours, commence en haut à gauche et va à droite. Les 2 premières opérations marquent pushun 1 sur la pile, puis de nouveau output, puisque la séquence de Fibonacci commence par deux 1, mais la boucle du programme principal n’imprime 1 fois qu’une seule fois. Ensuite, il pushreste 2 autres 1 sur la pile pour finir dans le magenta foncé en haut à droite pour démarrer la boucle du programme principal.

En descendant le côté droit de nous duplicateet outputd'imprimer le prochain terme de la séquence, puis à duplicatenouveau pour obtenir une copie de la valeur de la séquence actuelle. En partant du bas à gauche, vous exécutez 2 pushopérations. Comme la région rouge clair en bas à droite a une taille de 3 codes, le premier pushenfonce un 3 sur la pile au lieu d'un 1.

Monter dans le bleu clair est une rollopération. Cela supprime les 2 valeurs les plus élevées de la pile et effectue un nombre de lancers égal à la première valeur sautée, à une profondeur égale à la deuxième valeur sautée. Dans ce cas, il effectuera 1 rouleau jusqu'à une profondeur de 3. Un rouleau jusqu'à la profondeur nprend la valeur supérieure de la pile (notre valeur actuelle dupliquée) et l'enterre nprofondément. Notre pile est seulement 3 profonds en ce moment donc il va enterrer la valeur supérieure en bas.

Monter une fois de plus effectue une addopération en additionnant la valeur de séquence actuelle à la valeur de séquence précédente. Notre pile a maintenant la valeur de séquence suivante (nouvelle actuelle) en haut et la dernière valeur en dessous. Le programme passe maintenant à travers le blanc dans le magenta foncé pour recommencer la boucle.

Le motif jaune au milieu n'est jamais utilisé.

54 codes

Imprime "salut!" à stdout

Le message n’est pas particulièrement long, mais l’impression au pied prend une place surprenante. L'impression est effectuée à l'aide de valeurs unicode et les entiers sont placés dans la pile à l'aide de la taille de la région à quitter. Étant donné que nous avons un nombre très limité de codes pour ce défi, nous utilisons des calculs pour atteindre la plage imprimable souhaitée.

Le programme commence par un pushdes 5 de la région cyan à gauche. De là, il coule tout en haut avec 6 duplicateopérations pour amorcer la pile avec un groupe de 5. Suivant est push1, subtractmettre un 4 en haut de la pile, puis 2 multiplyopérations pour mettre 4 * 5 * 5 = 100 en haut de la pile. Puis un duplicatepour 2 100.

Maintenant, le programme rebondit sur le noir et commence à travailler à gauche le long du bas. Pushopérations de 3 et 2 puis a rollpour enfouir les 2 100 sous un 5. Vient ensuite push1, soustrayez, et ajoutez pour obtenir 100 + 5-1 = 104 en haut de la pile, ce qui correspond à "h" unicode. Les 2 opérations suivantes sont push1 et pointerpour contourner le coin et commencer à se déplacer tout au long du milieu, puis outputpour imprimer "h".

Suivant est add100 + 5 = 105 sur le dessus de la pile, et outputpour imprimer "i". La pile contient maintenant deux 5. Push1, add, multiplydonne (1 + 5) * 5 = 30. Enfin push3 et addpour 33, et outputpour le trailing "!". Le programme parcourt ensuite l’espace blanc restant pour se terminer par le vert à droite.

> <> (Poisson)

(Remarque: Certains extraits s'appuient sur des extraits précédents. Par conséquent, contrairement à la plupart des réponses, j'ai décidé de les mettre du plus tôt au plus tard.)

Factoïde:

Comme Befunge,> <> est un langage 2D basé sur une pile. Cela signifie que les instructions ne sont pas exécutées de manière linéaire comme dans la plupart des langages traditionnels - le déroulement du programme peut être ascendant, descendant, gauche ou droit!

Longueur 1 extrait:

X

Xest une commande non valide dans> <>, le message d'erreur something smells fishy...est donc imprimé. En fait, il s'agit du seul message d'erreur dans> <>, qu'il s'agisse d'une division par zéro ou d'une tentative de vidage d'une pile vide.

Longueur 2 extrait:

1n

Le flux de programme dans> <> commence en haut à gauche et est initialement à droite. 1pousse un 1 sur la pile, puis l’ nimprime sous forme de nombre (par opposition à un caractère ASCII). Cependant, les programmes> <> sont toroïdaux, ce qui signifie que le pointeur d’instruction s’allonge quand il atteint la fin d’une ligne. Donc, après le ndébut, appuyez sur 1, imprimez, revenez au début, appuyez sur 1, imprimez ... et nous finissons par imprimer 1pour toujours!

Longueur 3 extrait:

"o;

Voici l' "analyse de chaîne, la osortie sous forme de caractère ASCII et ;termine le programme. Mais que fait réellement le programme dans son ensemble?

Nous commençons par analyser les chaînes, en plaçant chaque caractère que nous voyons sur la pile jusqu’à ce que nous trouvions une fermeture ". Nous poussons un o, puis un ;... et renvoyons le pointeur d'instruction au début. Mais à présent ", nous arrêtons l' analyse des chaînes de caractères et, finalement, nous exécutons les commandes oand ;comme d'habitude pour imprimer le haut de la pile ;et terminer.

Oui, nous venons d'utiliser le même caractère de citation pour commencer et terminer une chaîne!

Longueur 4 extrait:

42n;

D'après ce que nous avons vu jusqu'à présent, vous pouvez vous attendre à ce que cela pousse 42, la sortie sous forme de nombre se termine ensuite. Mais toutes les instructions entre> <> sont des caractères simples, donc cela pousse en fait un 4 et un 2 , puis sort le haut de la pile sous forme de nombre (seulement le 2) et se termine.

Longueur 5 extrait:

<v
;>

Rappelez-vous que> <> est un langage 2D. Cela signifie qu'il doit y avoir des moyens de changer l'orientation du flux de programme!

Comme Befunge, vous pouvez le faire en utilisant les flèches >^v<. Pour illustrer leur fonctionnement, examinons le programme ci-dessus:

• Le flux du programme est initialement à droite
• < fait circuler le programme vers la gauche - nous partons de la gauche et retournons à la v
• v rend le programme flux vers le bas - nous descendons à la >
• > fait circuler le programme vers la droite - nous allons à droite et revenons à la ;
• Enfin, nous terminons.

Longueur 6 extrait:

";"00p

Une autre fonctionnalité intéressante de> <> est qu’il est réflexif - le programme peut modifier son propre code source à la volée!

Ici nous poussons un ;, suivi de deux zéros. psaute alors les trois premiers éléments y, x, v( yétant le sommet de la pile) et des lieux và la position x,y. En d'autres termes, pdans ce programme met un point-virgule à la position 0,0, transformant le code en ;;"00p. Cela permet ensuite au programme de se terminer, car le pointeur d’instruction tourne autour et exécute le nouvel élément placé ;.

Longueur 7 extrait:

\7*n;
6

Un comme Befunge,> <> a aussi des miroirs ( \/|_#) qui reflètent le sens de déroulement du programme. Donc ici nous:

• Commencez à droite, mais le \nous reflète vers le bas
• Poussez un 6 et envelopper
• Frapper le dos de la \et refluer vers la droite
• Poussez un 7
• Multipliez les deux premiers de la pile
• Sortir et terminer

Se déplacer horizontalement à travers un _miroir ou verticalement à travers un |miroir est une opération sans issue.

Longueur 8 extrait:

"r00g>o<

Probablement le plus simple> <> quine si une erreur est autorisée à être levée. Les deux nouvelles instructions sont les suivantes:

• r: Inverser la pile
• g: Get - pop y, xet place le personnage sur x,ydans la pile (contrepartie de p)

En utilisant l’astuce d’encapsulage de la chaîne d’avant, le programme appuie r00g>o<ensuite sur le premier guillemet. La pile est alors inversée, donnant <o>g00r. Après que nous poussons l'omble chevalier à 0,0la ", pour donner <o>g00r". Enfin, nous interceptons un oentre deux flèches, sortant le haut de la pile jusqu'à ce qu'il ne reste plus rien et que nous obtenons une erreur.

Longueur 9 extrait:

x0\>
\1n>

x(minuscule) déplace le pointeur d'instruction dans une direction aléatoire et le programme présente cette fonctionnalité en imprimant des bits aléatoires pour toujours. Essayez de suivre les flèches et les miroirs pour comprendre comment cela fonctionne! (N'oubliez pas de vérifier les quatre directions, y compris en haut et à gauche)

Longueur 10 extrait:

;a comment

Il n'y a pas de syntaxe de commentaire dans> <> - il n'en a pas besoin. Écrivez simplement ce que vous voulez n'importe où et assurez-vous qu'il ne soit pas exécuté sous forme de code!

Longueur 11 extrait:

1!X2!X+!Xn;

!est un trampoline qui saute des instructions. Il est particulièrement utile lorsqu'il est utilisé avec ?un trampoline conditionnel qui ouvre le haut de la pile et exécute l'instruction suivante si l'élément sauté n'est pas nul. Nous verrons comment cela fonctionne plus tard.

Le code ci-dessus imprime 3 en sautant le Xs, en exécutant seulement 1! 2! +! n;.

Longueur 12 extrait:

01v
ao>:@+:n

Imprime les numéros de Fibonacci pour toujours à partir de la seconde 1, un sur chaque ligne. Les nouvelles commandes sont:

• a: Poussez 10, ce dont nous avons besoin pour newline. a-fpoussez 10 à 15 respectivement.
• :: Dupliquer le haut de la pile
• @: Faire pivoter les trois premiers éléments de la pile, par exemple [5 4 3 2 1] -> [5 4 1 3 2].

Trace pour les premières itérations:

Longueur 13 extrait:

i:d=?v
l?!;o>

Un programme "tac" qui lit dans une ligne d’entrée et le sort inversé. Merci à @tomsmeding pour l'extrait.

=fait apparaître les deux premiers éléments et pousse 1 s'ils sont égaux, 0 sinon. La première ligne continue à lire en entrée jusqu'à ce que le caractère ASCII 13 (retour à la ligne) soit trouvé, point auquel il passe à la deuxième ligne.

La l?!;oboucle est une construction importante dans> <> qui génère la pile entière. Contrairement à >o<cela, cela ne cause aucune erreur. Voilà comment cela fonctionne:

• l pousse la longueur de la pile
• Nous vérifions la longueur avec ?:
  • Si la longueur était différente de zéro, l'instruction suivante !est exécutée, en sautant la;
  • Si la longueur était égale à zéro, alors nous n'exécutons ni n'exécutons en !raison de la;

Notez qu'aucune sortie ne se produit réellement jusqu'à ce que vous atteigniez le retour chariot.

Longueur 14 extrait:

32.

   X67*n;

En plus de changer la direction du déroulement du programme, vous pouvez déplacer le pointeur d’instruction où vous voulez!

.POP y, xet téléporte le pointeur d'instruction de x,ydirection maintien. Notez cependant que vous devez vous déplacer sur une case avant l'endroit où vous souhaitez vous rendre - le pointeur d'instruction est mis à jour avant l'exécution de l'instruction suivante. Donc, ici, le pointeur d’instruction tombe sur l’invalide X, mais tout va bien puisque le pointeur se déplace vers le 6avant de poursuivre l’exécution.

.permet de convertir la plupart des> <> programmes en une seule ligne, mais pourquoi voudriez-vous perdre le plaisir de la 2D? :)

Longueur 15 extrait:

01+:aa*=?;:nao!

Imprime les numéros 0à 99, un sur chaque ligne. Ce programme démontre une utilisation nette du !trampoline - pour s'assurer que le 0 initial n'est poussé qu'une seule fois.

Longueur 16 extrait:

"r00g!;oooooooo|

Une bonne quine qui ne jette pas d' erreurs, inspirée de la quine de la page esolang .

Si vous vous demandiez comment modifier la quine précédente (extrait # 8) pour ne pas causer d'erreur et que vous pensiez "pourquoi ne pas simplement ajouter une tonne d' oinstructions?", Vous réaliserez alors que pour chaque oajout, , vous devez sortir un autre o! Cette quine résout parfaitement le problème en plaçant un |miroir à la fin, ce qui permet à chacun od’être utilisé deux fois .

Si nous passons aux guillemets simples (qui sont également utilisés pour l'analyse syntaxique des chaînes), une autre méthode quine non utilisée gest la suivante:

'r3d*!;oooooooo|

Longueur 17 extrait:

b2,63,.

   17,n;

Nous avons addition ( +), soustraction ( -), multiplication ( *), modulo ( %) ... mais qu'en est-il de la division? C'est là, mais comme /c'est déjà un miroir, le ,symbole a été attribué à la division . Fait intéressant, la division est une division flottante , pas une division entière!

Le programme ci-dessus explore certains comportements indéfinis en essayant d'y accéder 11/2, 6/3. L’ intégrateur Python semble correct si la première coordonnée n’est pas un entier (bien qu’il saute au mauvais endroit), mais s’étouffe si la seconde ne l’est pas.

Longueur 18 extrait:

123456${{$}nnnnnn;

Nous avons vu rqui inverse la pile et @qui fait pivoter les trois premiers éléments. Voici quelques commandes supplémentaires qui déplacent des éléments sur la pile:

• $: Échanger les deux premiers éléments
• {: Décale toute la pile à gauche
• }: Décale toute la pile à droite

Pour montrer comment cela fonctionne, voici la trace du programme:

123456 ------> 123465 ------> 234651 ------> 346512 ------> 346521 ------> 134652
       $ Swap        { L shift      { L shift       $ Swap        } R shift

Ensuite, nous produisons en donnant 256431.

Longueur 19 extrait:

"reward"4[roooo]oo;

Jusqu'à présent, je disais "la pile", "la pile" ...

Bien que la plupart des programmes utilisent une seule pile,> <> peut en réalité avoir plusieurs piles! Voici les instructions pertinentes:

• [: Affiche xet déplace les xéléments supérieurs vers une nouvelle pile
• ]: Supprime la pile actuelle et déplace ses valeurs vers la pile sous-jacente.

Voici la trace du programme ci-dessus:

       [r e w a r d]       Push "reward"
4[     [r e] [w a r d]     Move four elements to a new stack
r      [r e] [d r a w]     Reverse the current stack
oooo   [r e] []            Output "ward"
]      [r e]               Remove the current stack, no values to move
oo     []                  Output "er", giving "warder" altogether

Notez que le simple fait de le repasser rewardpuis de le réimprimer avec ooooooimprimer entraînerait une impression draweren raison de la nature des piles "premier entré, dernier sorti".

Longueur 20 extrait:

aa*5+\
7a*2+\
oo;  \

Une caractéristique peu connue de> <> est que, comme Python, les barres obliques inverses peuvent être utilisées pour la continuation de ligne dans de nombreux cas. *

Le code ci-dessus est fonctionnellement identique à

aa*5+7a*2+oo;

^{* Avertissement: La raison pour laquelle cela fonctionne peut être ou ne pas être pour une raison complètement différente}

Longueur 22 extrait:

1&fv ;n&<
&1->:0=?^:&*

En plus des piles,> <> possède également des registres (un pour chaque pile) qui peuvent être utilisés pour stocker des valeurs. L'appel &pour la première fois déplace la valeur supérieure de la pile dans le registre et l'exécution à &nouveau la renvoie. Cela peut être très utile pour accumuler une valeur, par exemple des sommes et des factorielles.

Le programme ci-dessus calcule la factorielle de f(15), en imprimant 1307674368000. Voici la trace pour fremplacé par 4:

Longueur 24 extrait:

"Hello, World!"rl?!;of0.

Nous avons assez de personnages pour le programme préféré de tout le monde! Ici, nous utilisons le .téléporteur pour la boucle de sortie.

Longueur 25 extrait:

0i:0(?v$a*$"0"-+!
   ;n~<

Malheureusement, <> n'autorise la lecture d'un caractère à la fois dans STDIN, ce qui rend la lecture en chiffres un peu délicate. Pour les entrées composées des chiffres 0 à 9, ce programme est essentiellement atoi, convertissant une chaîne de chiffres de STDIN en un nombre sur la pile (qui est ensuite imprimé).

Une autre remarque est que sur EOF, ipousse -1 sur la pile. Cela facilite la vérification de la fin de fichier en comparant à 0 avec (, ou "inférieur à".

Cet extrait utilise également ~ce qui permet d’afficher et de supprimer l’élément supérieur de la pile.

Longueur 33 extrait:

i>:nao:1=?;\
 ^  ,2v?%2:/
 ^+1*3<

Jusqu'à présent, la plupart des extraits étaient soit relativement linéaires, soit constitués simplement de simples exemples démontrant la fonctionnalité de> <>. Maintenant, je peux donner un exemple qui montre à quel point il est facile de visualiser le déroulement du programme> <> avec un programme bien conçu.

Le programme lit un seul caractère ASCII et exécute l' 3x+1algorithme sur son point de code (In> <>, les caractères sont essentiellement des entiers). Chaque étape de l’algorithme est imprimée jusqu’à atteindre 1.

Voici une trace des premières itérations avec entrée a(point de code 97):

Longueur 44 extrait:

a&>i:0(?v"+"$\
/&^?=0l< "a*"/
\:1+&2p/\0
n
;

Je n'ai pas l'impression d'avoir rendu pjustice au commandement, je ne l'ai utilisé qu'une seule fois dans l'extrait n ° 6; voici donc une fonction atoi différente. Qu'est-ce qui est cool à propos de celui-ci? Le programme écrit l'expression nécessaire pour calculer le nombre pendant la lecture de l'entrée!

Donc, pour les entrées comme 573après la lecture de tous les caractères, la fin de la troisième ligne ressemblera \0a*5+a*7+a*3+à 573!

Encore une fois, l’entrée devrait être composée uniquement de chiffres. Trace GIF ici .

Longueur 74 extrait:

>i:'A'(?v:'N'(?v:'['(?v\
  :'a'(?v:'n'(?v:'{'(?v\
^      o<    +d<  -d-d<o

Si vous avez réussi à en venir ici, vous serez peut-être d’accord avec moi pour dire que c’est un programme ROT13 très lisible. Étant donné un caractère c1, nous trouvons le premier caractère c2dans AN[an{, tel que c1 < c2, puis appliquons le décalage approprié en ajoutant / soustrayant d(13). Notez que [et {sont les caractères directement après Zet zrespectivement.

Essayez-le dans la console et regardez les lettres se transformer au fur et à mesure que vous tapez!

^{(Vous pouvez également canaliser l'entrée, mais comme je manque la vérification EOF, :0(?;une erreur s'est produite lors de la tentative d'impression de -1 sous la forme d'un caractère).}

C - modifier

Merci pour les votes! Comparé à d'autres langages et à ce qu'ils peuvent faire avec un nombre d'octets limité, C a l'air obsolète, difficile et trop dépendant du développeur. À bien des égards, les langages scriptés et de niveau supérieur avec gestion automatique de la mémoire sont beaucoup plus expressifs et plus rapides à produire que C ne le sera jamais.

Alors, pourquoi en vedette C?

Le secret caché derrière tous ces langages de script est que les interprètes sont probablement écrits en C (ou plus récemment, en C ++ ou en Java). Les premiers compilateurs C ++ réellement compilés en code C. En fait, tant qu'il n'y a pas de marché pour un compilateur direct, il est généralement plus rentable d'écrire un compilateur pour générer C, puis de le compiler.

Si vous travaillez sur de très petites plates-formes, peut-être même sans système d'exploitation disponible, vous travaillerez probablement en C. De nos jours, à peu près tous les appareils ont un microcontrôleur intégré, sans doute programmé en C. Quand ils en ont besoin petit et rapide, C est le chemin à parcourir. (Aussi FORTH, pour les masochistes.)

Connaître C vous rapproche le plus possible du métal sans entrer dans assembleur et vous aide dans d’autres langues. Vous avez une bonne idée du fonctionnement d’une fonction virtuelle C ++. Vous savez que lorsque vous écrivez ces fonctions récursives de définition de valeur en PHP, en interne, il effectue beaucoup d’allocation de mémoire et de copie. Vous essayez donc instinctivement de procéder à une définition de référence. Les rappels et les références ne font pas peur aux développeurs C, peut-être que Haskell le fait.

Comme Kernighan et Ritchie l'ont mentionné dans leur préface du langage de programmation C classique , 2e édition, le langage C n'est pas un gros langage et il n'est pas bien servi par un gros livre. J'essaie de suivre ce conseil: les exemples font un devoir double, triple ou plus si possible.

Tous les extraits sont au moins compilables par eux-mêmes. Ceux qui sont liés et exécutables sont indiqués comme tels. Je sais que ce n'est pas une obligation, mais cela simplifie la tâche en expliquant le cadre requis pour que tout extrait de code fonctionne.

J'ai également essayé de faire en sorte que chaque extrait de code soit le plus court possible, de manière à ne pas introduire d'espaces supplémentaires pour simplement couvrir une certaine longueur. Dans les cas où le code est en retrait, les retraits ne sont pas inclus dans la longueur, mais un caractère pour chaque nouvelle ligne.

Factoïde

C roches.

Longueur 0 extrait

Le programme d'auto-reproduction le plus court au monde http://www.ioccc.org/1994/smr.hint

Longueur 1 extrait

;

C fait la distinction entre la compilation et la liaison. De nombreuses entités en C ne sont que compilées et liées plus tard - par exemple, toutes les bibliothèques statiques et dynamiques.

D'autres entités sont simplement incluses et ne génèrent aucun code par elles-mêmes.

Le point-virgule ci-dessus sera certainement compilé en code objet et ne fera rien!

Longueur 2 extrait

x;

C, étant un ancien langage de programmation, a connu plusieurs itérations. Le plus ancien en utilisation répandue a été développé par Kernighan et Ritchie et abrégé K & R. K & R C est remarquable pour avoir formulé beaucoup d'hypothèses sur votre code si vous ne les fournissez pas explicitement.

En particulier, dans K & R C, le code ci-dessus est supposé être un entier global xinitialisé à 0. Le compiler en mode K & R produira un fichier objet qui fournit à tout programme la reliant à cette variable pour son utilisation.

Longueur 3 extrait

??/

C est tellement répandu qu’il doit fournir des fonctionnalités de compatibilité pour les systèmes n’ayant pas tous les caractères qu’il utilise. Ce qui précède est un trigraphe pour la barre oblique inversée, qui est utilisé en C comme caractère de continuation de ligne. Ce qui précède sera compilé, probablement avec un avertissement qu’il n’ya pas de ligne suivante.

Une culture commune en C consiste à ignorer les avertissements de compilation, et de nombreuses bases de code volumineuses ont invariablement quelques avertissements ou plus lors de leur construction.

Longueur 4 extrait

f();

Toujours avec K & R, ce qui précède est "rempli" pour signifier lors de la compilation qu '"il existe, avec un lien global, une fonction f à fournir ultérieurement, qui prend un nombre d'arguments fixe mais non spécifié et renvoie un entier."

Notez les différences fondamentales entre cela et f;.

Longueur 5 extrait

s="";

K & R C est remarquable pour être vraiment indulgent. Lors de la compilation, ce code fournira un entiers pour la liaison globale qui est initialisé à l'adresse de départ d'une chaîne vide (je pense). K & R gère discrètement toutes les contraintes, y compris la troncature si un entier n'est pas assez grand pour contenir l'adresse.

Ce sont des constructions comme celles-ci qui ont généré de nombreux bugs difficiles à trouver et ont beaucoup inspiré les compétitions IOCCC.

Longueur 6 extrait

o=042;

Un 0, même un vieux chiffre, signifie que les chiffres suivants sont dans la base octale. Lors de la compilation, le code ci-dessus fournira un entier opour la liaison globale initialisée au nombre décimal 34.

Cette fonctionnalité de C a piqué de nombreux développeurs qui s'efforcent de compiler leurs chiffres pour les aligner agréablement!

Longueur 7 extrait

f(){f;}

Le code ci-dessus est une fonction avec un corps. Mais que fait-il? Il récupère l'adresse de la fonction et ne fait rien avec elle! Généralement, ce que la fonction retournera est indéfini. Un code insensé comme celui-ci peut souvent être compilé sans avertissement.

Longueur 8 extrait

main(){}

Cela représente le code compilable et pouvant être lié le plus court en C. Alors que dans les versions modernes de C, les fonctions ne peuvent généralement pas être définies implicitement, cette restriction est assouplie pour des raisons historiques main.

Cette merveille d'un programme, qui ne fait que renvoyer 0, compilera à une taille non négligeable et se liera à diverses routines d'exécution en C. Vous pouvez compiler et lier avec une verbosité définie sur full pour voir ce qui se passe sous le capot.

Longueur 9 extrait

#define Z

Un pilier des fichiers d’en-tête C est le #define directive préprocesseur. Les programmes C sont compilés à différentes étapes et, à l’une de ces étapes, ces définitions sont remplacées par leurs valeurs réelles.

Si un argument est manquant, C impliquera 1, de sorte que ce qui précède serait substitué 1partout où il Zest utilisé dans le code source.

Ce qui précède serait généralement placé dans un fichier d’en-tête et #included au besoin.

Longueur 10 extrait

enum{P,Q};

Le enummot-clé fournit un moyen parfois sûr de taper pour définir une série de constantes. Comme définit, ils sont souvent utilisés dans les fichiers d’en-tête. Le code ci-dessus, lorsqu'il est inclus, définirait Pun entier de 0 et Qde 1.

Longueur 11 extrait

volatile v;

Le volatilemot clé est d'informer le compilateur qu'une variable peut être modifiée par d'autres agents et de ne pas supposer qu'elle restera constante entre les accès.

Longueur 12 extrait

#pragma once

#pragma once est une directive de préprocesseur non standard, mais largement prise en charge, indiquant que le fichier source actuel ne doit être inclus qu'une seule fois dans une compilation unique.

La technique traditionnelle et entièrement prise en charge consiste à utiliser des #includegardes avec les inconvénients du code ajouté et des conflits de noms possibles.

Longueur 13 extrait

w(){for(;;);}

Il existe de nombreuses conventions en C, et l'une d'elles est la façon de représenter des boucles infinies. Dans ce cas, for(;;)indique aucune initialisation, aucune vérification de sortie, dont la valeur par défaut est 1, c'est-à-dire true - c.-à-d.

Parfois, il est possible de tout faire à l'intérieur du ()et la boucle elle-même n'a pas besoin de corps. Dans ce cas, un point-virgule factice est ajouté à la fin.

Dans le code ci-dessus, une fois compilé, il fournira une fonction qui entrera dans une boucle occupée serrée - l'un des no-no de la conception logicielle - et ne reviendra jamais.

Longueur 14 extrait

int a[]={1,2};

Les tableaux en C n'ont pas besoin des longueurs spécifiées. Les crochets vides []indiquent au compilateur de "comprendre vous-même". Cependant, en C, contrairement aux autres langues, il n’existe pas de moyen intégré pour empêcher l’accès à un tableau en dehors de ces limites, ce qui conduit à la métaphore "se tire dans le pied" pour laquelle C est connu.

Le code ci-dessus, une fois compilé, fournira un tableau global mutable ade deux entiers initialisés avec 1 et 2.

Longueur 15 extrait

const long k=7;

Le constspécificateur est un ajout ultérieur à C emprunté à C ++. Une question commune à l’entrevue est "Est-il judicieux de définir une variable comme volatile const?". constavec enumet inlinesont destinés à réduire la dépendance sur #definece qui a des problèmes avec la sécurité de type.

Longueur 16 extrait

extern void **q;

externest utilisé pour indiquer qu'une variable est déclarée ailleurs. Le void *type est le type générique standard en C, ce qui signifie qu'il n'est pas nécessaire de explicitement le transtyper ou le transtyper dans les instructions d'affectation. La **séquence d'opérateur signifie pointeur sur un pointeur, ce qui frappe souvent l'esprit des débutants, mais est parfaitement valide et souvent utilisé C.

Longueur 17 extrait

double d=4/3-1/3;

Si vous deviez imprimer ce qui précède, le résultat serait un et vous vous en diriez super! Changer pour double d=4/3-2/3;et quelle est la réponse? C'est toujours un! C utilise une arithmétique entière pour calculer 4/3 → 1 et 2/3 → 0 et 1 - 0 → 1!

Longueur 18 extrait

main(){puts("!");}

Nous arrivons enfin à un code qui fait quelque chose! putsest un favori des golfeurs C, car il ne nécessite pas de fichier d'en-tête à utiliser.

putsajoutera également un saut de ligne à la sortie. Inversement, son homologue getssupprimera les sauts de ligne. Il ne faut jamais utiliser getssauf dans des circonstances très contrôlées - il n’est pas protégé contre les dépassements de mémoire tampon et est à l’origine de nombreux exploits.

Longueur 19 extrait

#include <stdlib.h>

L'inclusion de fichiers d'en-tête est souvent une signature personnelle des développeurs. Beaucoup incluent libet iopeu importe si elles sont nécessaires. Certains ordonnent les fichiers d'en-tête pour que les longueurs augmentent ou diminuent. La plupart mis <>avant "". Personnellement, j’ai utilisé cette signature lors de mes journées d’assistance technique pour vérifier si un étudiant avait triché: même signature en-tête? regarde plus attentivement!

Longueur 20 extrait

char*p=(char*)0x300;

C est conçu pour être utilisé sur des plates-formes rudimentaires de très bas niveau. Dans certains cas, vous devrez peut-être accéder directement à des ports mappés en mémoire spéciaux.

Dans le code ci-dessus, l'adresse d'un port est définie en hexadécimal 300. Vous pouvez accéder à la valeur du port en utilisant *p, comme *p=0xff;pour activer tous les bits, ou v=*p;pour récupérer la valeur actuelle.

Longueur 21 extrait

int w=sizeof(double);

L' sizeofopérateur fournit la taille en octets d'un type. Avec les noms de variables, les crochets ne sont pas obligatoires, par exemple double d;int w=sizeof d;.

Longueur 22 extrait

asm("xorl %ecx,%ecx");

Comment asmdoit être utilisé est défini par le compilateur. Ce qui précède est un exemple de code en ligne Linux gcc sur une plate-forme Intel.

L'Unix d'origine avait une fraction petite mais non négligeable de son code en assembleur. Même aujourd'hui, si la vitesse est une préoccupation majeure et que la portabilité ne l'est absolument pas, vous la verrez utilisée.

Sur les systèmes compatibles, le code ci-dessus sera compilé et il s'agira littéralement d'une instruction d'assemblage isolée sans aucun moyen classique d'y accéder! BTW xor R,Rest un langage courant en langage assembleur permettant d’effacer rapidement un registre.

Longueur 23 extrait

union u{char c;int i;};

A unionfournira au moins assez d’espace pour le plus grand élément. Vous pouvez le voir utilisé conjointement avec void *pour fournir un type "opaque" commun dans certaines bibliothèques. Dans ce cas, l'union fera généralement partie d'une structure plus grande, la structure ayant un champ pour identifier le type d'union.

Longueur 24 extrait

/*INTS*/int i,j,k;//INTS

Le commentaire C d'origine a été délimité comme /* comment */et a emprunté le // comment to end of lineformat au C ++.

Longueur 25 extrait

int main(void){return 1;}

Ceci est la version la plus conforme du fragment de longueur 8 ci-dessus. Le type de retour et les types de fonction sont spécifiés et sa valeur est explicitement renvoyée.

La convention en C consiste à utiliser une valeur de retour de 0succès et 1échec, ou si vous souhaitez être strictement conforme EXIT_SUCCESSet EXIT_FAILUREtel que défini dans stdlib.h.

Longueur 26 extrait

typedef struct{int x,y;}P;

typedefest extrêmement utile, en particulier typedef struct,. En termes modernes, vous pourriez l'appeler "objet-orientation-lumière".

Après avoir inclus ce qui précède, le code peut être utilisé Pcomme type normal dans les déclarations et les fonctions, avec vérification de type complète. Contrairement à C ++, vous ne pouvez pas définir d'opérateurs tels que +, * ou <<, d'où «object-orientation-light».

Longueur 27 extrait

#define C(x,y)(((x)+1)*(y))

C a une #definesyntaxe de macro commode .

Une erreur courante de débutant consiste à omettre les crochets intérieurs et / ou extérieurs, ce qui entraîne des erreurs de priorité difficiles à trouver par l'opérateur.

Longueur 28 extrait

struct f{int s:1,e:8,m:23;};

C peut définir explicitement des champs de bits pouvant être attribués, lus et manipulés comme n'importe quel entier.

Ce qui précède est une approximation d’une structure de données à virgule flottante simple largeur IEEE.

Longueur 36 extrait

f(unsigned x){return!!x&!(x&(x-1));}

Dans de nombreuses langues, vous n'avez pas besoin de vous soucier de la façon dont les nombres sont représentés. En C, vous devez être parfaitement au courant de leur représentation interne.

Le meilleur exemple de ceci auquel je peux penser consiste à déterminer si un entier est une puissance de deux {1, 2, 4, 8, ...}. Ceux qui ne sont pas familiers avec C feront des boucles, des décalages et toute sorte de choses pour le temps d’exécution de O (log (n)). Je vais le laisser comme exercice au lecteur pour confirmer que ça marche, mais ça marche vraiment ...

La !!convention est souvent utilisée pour contraindre un nombre entier différent de zéro et zéro à 1 et 0 respectivement. Beaucoup de développeurs C aiment utiliser ce genre de trucs (souvent à la différence de ceux qui valorisent la clarté du code).

Les développeurs super passionnés de C peuvent confirmer que ce qui précède fonctionnera sur du matériel complémentaire et signé. Pour ceux qui se le demandent, vous êtes presque certain de travailler actuellement sur du matériel à double complément. Seuls les vraiment chanceux (ou malchanceux selon votre perspective) doivent s'inquiéter de cela!

Longueur 48 extrait

#include<complex.h>
double complex c=3.0+I*4.0;

C99 prend en charge les nombres complexes. Comme vous pouvez le constater d'après le code, il prend la forme d'un modificateur pour un type réel. Vous pouvez aussi utiliser, int complex c=3+I*4;mais en interne, cela oblige à un type à virgule flottante. Le code ci-dessus sera compilé en gcc avec gcc -std=c99 -c length-48.c.

Si vous voulez voir plus d'éléments internes, essayez de compiler avec le commutateur -E. Pour ma version de gcc, la déclaration ci-dessus devient double _Complex c=3.0+(__extension__ 1.0iF)*4.0;. Notez que le type complexe est un ajout significatif à la langue, pas seulement quelques macros bon marché.

Ceci est juste un teaser, quand nous avons plus de 125 caractères, alors nous pouvons commencer à nous amuser vraiment avec des nombres complexes!

Longueur 51 extrait

#include <math.h>
main(){double d=sqrt(sin(3.2));}

Pour diverses raisons, C ne fait pas automatiquement le lien avec les fonctions mathématiques standard telles que sin, cos, tan, sqrt, etc. Ainsi, si elles sont utilisées, mais non liées, le développeur se verra attribuer la référence indéfinie d' erreur de l'éditeur de liens à 'sqrt' , ou une autre erreur.

En gcc, le code ci-dessus va compiler et lier en utilisant gcc length-51.c -lm.

Note sin(3.2)renverra un nombre négatif, dont la racine carrée n’est pas légale dans le domaine réel. En C, une valeur spéciale NaNest renvoyée pour indiquer cette erreur, que le programme est libre d’ignorer!

En C99, de nombreuses nouvelles fonctions de gestion des exceptions offrent un contrôle très sûr et précis de ce type d’erreurs mathématiques, que personne n’utilise!

Longueur 63 extrait

static int w;static int X(int x){static int s=0;s^=x;return s;}

Ou formaté plus sainement:

static int w;
static int X(int x)
{
    static int s=7;
    s^=x;
    return s;
}

Comme vous l'avez peut-être deviné, il s'agit du mot clé staticqui a plus d'une signification en C.

Dans les deux premiers cas, staticindique au compilateur que l'entier wet la fonction Xne sont pas visibles en dehors de ce fichier ou de cette unité de compilation, c'est-à-dire qu'ils sont internes.

Ces fonctions ne sont pas destinées à être appelées de manière externe. Par conséquent, elles pourraient ne pas vérifier la validité des arguments et couper d'autres angles. Parce qu'ils ont une portée interne, vous pouvez redéfinir wet Xdans d'autres fichiers, et ils seront généralement séparés.

Dans le dernier cas, staticindique que l'entier sconserve sa valeur entre les appels de fonction. La première fois Xest appelé, ssera sa valeur initiale 7, quand il est exclusif-OUed avec x, la nouvelle valeur sera conservée.

En interne, bien que cela dépende de la mise en oeuvre, l'organisation mémoire habituelle est celle qui sréside sur le tas, en particulier la mémoire initialisée, tandis que l'argument xréside sur la pile. La localisation des variables est importante si vous souhaitez implémenter des algorithmes récursifs, par exemple.

Un gotcha en C sont des affrontements avec des variables globales. Until wet Xsont réellement définis comme static, s’ils sont définis globalement quelque part, wet Xferont alors référence aux entités globales.

Ici qet wne peut pas être initialisé à la même valeur, car un global west utilisé pour définir q:

static int q = w;
static int w;

Si un global wn'existe pas, la compilation devrait échouer.

Ici qet wsera initialisé à la même valeur:

static int w;
static int q = w;

En règle générale, les concepteurs réduisent les conflits de noms en ajoutant un préfixe ou un suffixe distinctif à leurs variables et fonctions globales.

En C99, statica gagné une autre utilisation, par exemple int Y(int a[static 10]);ce qui signifie qu’il existe une fonction Yqui prend un tableau d’ au moins 10 entiers.

Longueur 74 extrait

void f(register int*p,register int*q,register int l){while(l--)*p++=*q++;}

Ou bien aménagé:

void f(register int *p, register int *q, register int l)
{
    while (l--)
        *p++ = *q++;
}

Le mot-clé registerindique au compilateur que l'utilisation de registres de matériel serait avantageuse ici. La fonction ci-dessus copiera les lentiers de qà p, en utilisant si possible des registres de matériel.

Parfois, les accélérations peuvent être importantes. Par exemple, dans la famille des microprocesseurs 68K, la ligne *p++ = *q++pourrait être traduite en une seule instruction, au lieu de MOVE.W (Ap)+,(Aq)+six ou huit si vous ne l’utilisez pas register. Le microprocesseur 68K avait des modes explicites de post-incrémentation et de pré-décrémentation, de sorte que le développeur averti, s’il connaissait la plate-forme, adapterait le code en utilisant x++and --yvs. ++xet y--.

Ces jours-ci, les compilateurs ignorent généralement la registerpossibilité d'adresser des adresses (par exemple, ce &lqui entraînerait une erreur du compilateur).

Longueur 88 extrait

#include<stdio.h>
int f(int x){return(x>1)?x*f(x-1):1;}int main(){printf("%d\n",f(12));}

Ou avec une disposition plus saine:

#include <stdio.h>

int f(int x)
{
    return (x > 1)? x * f(x - 1): 1;
}

int main()
{
    printf("%d\n", f(12));
}

Ah, la récursion! Le fragment est un programme complet pour compiler, lier et exécuter. La fonction fcalcule la factorielle de son argument xen utilisant la formule récursive f (x) = x * f (x - 1). Les factorielles grossissent très vite, par exemple, f(12)est la plus grande valeur que vous puissiez obtenir dans un entier signé de 32 bits.

Pour un exemple de code vraiment récursif, examinez les implémentations naïves de la fonction Ackermann .

Les compilateurs intelligents peuvent optimiser la fonction, en utilisant le conseil inlineet "dérouler" la fonction lorsque des constantes sont fournies en tant qu'arguments de sorte que:

f(12)

Devient:

12 * 11 * 10 * 9 * 8 * 7 * 6 * 5 * 4 * 3 * 2 * 1

Sans aucun appel de fonction requis!

D'autres compilateurs peuvent réorganiser la fonction:

int f(int x)
{
    return (x < 2)? 1: f(x - 1);
}

Et implémentez quelque chose appelé queue-récursion. Ceci remplace en fait le dernier appel de fonction à un simple goto et permet à cette fonction de gérer le retour. L'avantage est que moins de pile est lancée, du code plus rapide et plus petit.

En langage assembleur, ce type d'opportunités d'optimisation est très facile à repérer et peut être implémenté par un "optimiseur de trou de serrure", qui recherche essentiellement de petits motifs et les remplace par quelque chose de plus rapide et / ou plus petit.

Longueur 117 extrait

#include<stdio.h>
int main(int c,char**v){int a,b;sscanf(v[1],"%d%*[\t ,]%d",&a,&b);printf("%d\t%d\n",a,b);return 0;}

Ou:

#include <stdio.h>

int main(int c, char **v)
{
    int a, b;

    sscanf(v[1], "%d%*[\t ,]%d", &a, &b);
    printf("%d\t%d\n", a, b);

    return 0;
}

C emprunté aux langages contemporains de l’époque, le concept d’une E / S universelle pouvant s’appliquer de manière cohérente à n’importe quel périphérique, qu’il soit une console, une carte perforée, une bande, un disque ou une imprimante, mais sous une forme véritable C, il permettait au développeur de créer déclarations très laconiques mais puissantes.

Dans l'extrait de code ci-dessus, il faut une entrée de ligne de commande, analyser deux entiers séparés par des espaces, des tabulations ou des virgules, puis les afficher. Il tire parti d'un scanfspécificateur plus récent %*[\t ,]qui: [\t ,]extraira tous les onglets, espaces et virgules et: les *ignore.

Je me souviens d’avoir révisé du code C ++ dans lequel le développeur faisait tout ce qui était «pur» de la manière C ++ avec <<un arsenal de méthodes comme findet substr. C’était au moins une douzaine de lignes et il ne pouvait toujours pas traiter les virgules comme des séparateurs. J'ai remplacé tout ce code maladroit par une seule sscanfligne comme ci-dessus!

Longueur 132 extrait

#include<stdio.h>
int main(int c,char**v){while(--c){++v;printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n",*v,*v,*v,*v,*v);}return 0;}

Ou:

#include <stdio.h>

int main(int c, char **v)
{
    while (--c)
    {
        ++v;
        printf("|%s|\n|%5s|\n|%-5s|\n|%.5s|\n|%5.5s|\n", *v, *v, *v, *v, *v);
    }

    return 0;
}

Les fonctions printf, sprintf, fprintfetc. spécificateurs de format d'utiliser pour définir la largeur et de rembourrage de la sortie.

Compilez et exécutez ce qui précède à l’aide des arguments de ligne de commande pour afficher les différentes sorties:

> main xyz 123456
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                              
|xyz  |                                                                                                                                              
|xyz|                                                                                                                                                
|  xyz|                                                                                                                                 
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|123456|                                                                                                                                             
|12345|                                                                                                                                              
|12345| 

Notez que .5la sortie du spécificateur est limitée à cinq caractères au maximum , tandis que l'interligne 5garantit que la sortie est d'au moins cinq caractères et -indique l'alignement à gauche. Leur combinaison définit la sortie avec exactement cinq caractères.

Code machine x86

Factoïde:

Le code machine x86 est la version assemblée de l'assemblage x86 que le processeur exécute réellement. Il a été développé à une époque où la mémoire et l’espace de stockage coûtaient cher, et a été conçu pour être quelque peu rétrocompatible jusqu’à Intel 8008. Un des objectifs était de garder un code exécutable réduit. Il utilise des instructions de longueur variable et une architecture CISC pour atteindre cet objectif (ce qui a eu l’inconvénient de compliquer davantage l’amélioration des performances des processeurs modernes). Ceci, allié à la simplicité de l'assemblage et au code machine en général, donne aux programmes x86 la capacité d'être extrêmement compacts.

Longueur 1:

Maintenant pour le premier programme:

0xC3

Ouvrez un éditeur hexadécimal, entrez cet octet et enregistrez-le sous test.com.

Vous avez maintenant un programme MS-DOS valide qui retourne immédiatement sans rien faire, puisque 0xC3 est l'instruction 'RET'. Cela montre cependant un autre aspect intéressant du golf avec x86: le format de fichier .com. Ce format exécutable n'a absolument aucun en-tête - le fichier est simplement chargé en mémoire à partir de l'adresse 0x100, puis l'exécution commence à 0x100. Cela signifie pas d'octets perdus sur les métadonnées!

Longueur 2:

Notre prochain programme:

0x4D 0x5A

ou 'MZ' en ASCII.

Ok, j'ai un peu triché, ce n'est vraiment pas un programme utile, car il correspond aux instructions

DEC     BP
POP     DX

Qui ne sont pas réellement utiles pour démarrer un programme .com. En fait, c'est tout l'intérêt de ces deux valeurs: aucun fichier .com raisonnable ne devrait commencer par elles! La taille des fichiers .com était limitée à 65280 octets (64 Ko - 0x100). Par conséquent, lorsqu'un programme plus volumineux commençait à être nécessaire, un nouveau format devait être développé. C'était le format de fichier .exe, qui a un en-tête. Cependant, MS-DOS devait conserver l'extension .com sur certains composants pour assurer la compatibilité ascendante. Il fallait donc un moyen de détecter si un fichier .com était vraiment un fichier .exe. Ils ont choisi l'aiguillon «MZ» comme numéro magique et, à ce jour, si vous ouvrez un fichier Windows .exe (ou .dll) dans un éditeur hexadécimal, vous verrez qu'ils commencent par ces deux octets. Cela m'amuse que même le programme Windows le plus moderne commence par une contrainte de compatibilité des années 70.

Longueur 3:

Maintenant pour une boucle infinie:

41 E2 FD

Ce qui se traduit par

start:
inc cx
loop start 

Ce programme incrémente la valeur de CX (qui sera> 0 pour commencer), puis exécute l'instruction de boucle. Loop est un excellent exemple d’instruction CISC car il combine 3 opérations simples en une opération spécifique: décrémente la valeur de CX, vérifie si elle est égale à 0 et saute à l’étiquette cible. Il existe également des formes de boucle qui vérifient les autres drapeaux en plus de se terminer lorsque CX est égal à 0. Nous aurions pu simplement effectuer un «démarrage rapide» pour une boucle infinie de 2 octets, mais c'était plus intéressant.

Longueur 4:

Un programme peu utile:

40 CD 10 C3

Traduit en assemblage:

inc ax    ; 1 byte
int 10h   ; 2 bytes
ret       ; 1 byte

Ce programme définit la console sur 40x25 caractères, efface l'écran, puis retourne à la ligne de commande. AX est réglé sur le mode vidéo souhaité (1), puis l’interruption du BIOS 10h est appelée pour définir le mode vidéo et effacer la fenêtre avant de revenir. Attendez-vous à voir plus d'interruptions de ce BIOS dans le futur.

Longueur 5:

Nous pouvons maintenant mettre en place un programme de pause:

B4 01 CD 21 C3

Traduit en assemblage:

mov ah,1  ; 2 bytes
int 21h   ; 2 bytes
ret       ; 1 byte

Ce programme indique au BIOS d'attendre qu'une touche soit enfoncée et la répète à l'écran avant de revenir. Cela montre également comment, sur le x86, certains registres peuvent être partiellement lus ou écrits. Dans ce cas, nous définissons l'octet supérieur de AX (AH) sur 1. Sur les processeurs 32 bits, vous pouvez également opérer sur les 16 bits inférieurs sans affecter les 16 bits supérieurs. Cette possibilité de modifier des registres partiels peut être pratique pour les programmeurs d’assemblage, mais présente des inconvénients pour les processeurs modernes qui tentent d’exécuter une exécution dans l’ordre , car ils peuvent introduire de fausses dépendances de données.

Longueur 9:

Maintenant, pour afficher réellement la sortie:

68 00 B7 07 AB 40 79 FC C3

Traduit en assemblage:

; These two instructions set up ES, the 'extra segment'
push 0xb700 ; 3 bytes
pop  es     ; 1 byte
label:
stosw       ; 1 byte, Store Word - Copy AX to [ES:DI] then add 2 to DI
inc  ax     ; 1 byte
jns  label  ; 2 bytes, Jump Not Signed - Jump unless the sign flag is set (when inc AX yields 0x8000
ret         ; 1 byte

La sortie est le jeu de caractères par défaut répété dans des couleurs différentes. L'octet de poids faible de AX est le code de caractère, et l'octet de poids élevé spécifie les couleurs à utiliser.

Les programmes 16 bits ne peuvent s’adresser directement qu’à 64 Ko. Pour contourner ce problème, le x86 utilisait des «segments», des registres spéciaux qui seraient multipliés par 16 et ajoutés à tous les accès en mémoire pour donner 20 bits de mémoire adressable. Un programme peut modifier les valeurs de ces registres de segments afin d’accéder à davantage de mémoire - ou à des zones spéciales de la mémoire: ce programme modifie le segment supplémentaire afin d’écrire dans la mémoire vidéo. Différents types d'accès mémoire utilisaient différents registres de segments, ce qui permettait au code, aux données et à la pile d'être accessibles simultanément dans différents blocs de mémoire. Le segment par défaut peut également être remplacé pour de nombreuses instructions.

Longueur 20:

Faisons quelque chose de reconnaissable - nous allons utiliser la 'règle 90' ​​pour dessiner des triangles de Sierpinski.

B0 13 CD 10 68 0F A0 1F AC 31 C2 88 94 3E 01 87 D3 93 EB F4

En assemblée:

mov al,13h      ; 2b
int 10h         ; 2b - Set the video mode to 13h

push    0xA00F  ; 3b
pop     ds      ; 1b - Set the data segment to video memory

start:          ; This loop runs 'Rule 90' to draw Sierpinski triangles
lodsb           ; 1b - load al with [ds:si] then increment si

xor     dx,ax   ; 2b - xor the left and right values of the previous row of pixels
mov     [si+318],dl ;4b - store result to memory

xchg    dx,bx   ; 2b - swap register values
xchg    ax,bx   ; 1b - swapping with ax is 1 byte shorter

jmp     start   ; 2b - infinite loop

Exemple de sortie:

Pour ce programme, nous utilisons le fameux 'Mode 13' - un mode graphique qui a une résolution de 320x200 avec 256 couleurs. Il a été utilisé par de nombreux jeux DOS populaires , tels que Doom.

Longueur 21

Voyons qui a fabriqué le processeur sur lequel nous travaillons.

0F A2 66 60 BB EE FF B9 0C 00 8A 17 43 B4 02 CD 21 E2 F7 FF E1

Traduit en assemblage:

cpuid         ; 2b  CPU ID - retrieve processor information based on the value in AX. For AX=0,
              ;     the 12 bytes in EBX, ECX, and EDX are loaded with a vendor identification string
pushad        ; 2b  Push all registers on the stack (32 bit version)
mov  bx,0xffee; 3b  Start of the vendor identification string on the stack
mov  cx,12    ; 3b  12 characters to print
print:    
mov  dl,[bx]  ; 2b  Character to print
inc  bx       ; 1b  Advance string position
mov  ah,2     ; 2b  Set AH to the 'Print character to STDOUT' value
int  21h      ; 2b  Call the bios interrupt to print
loop print    ; 2b  Decrement CX and jump if it is not zero
jmp  cx       ; 2b  Instead of restoring the stack, just jump right to the exit point

Exemple de sortie:

c:\misc>cpuid.com
GenuineIntel

Ce programme utilise l'instruction CPUID pour obtenir des informations sur le processeur sur lequel il s'exécute, en particulier la chaîne d'identification du fournisseur. La plupart des gens verront «GenuineIntel» ou «AuthenticAMD», à moins que le fabricant de leur processeur ne soit inhabituel ou qu'ils ne fonctionnent pas sur certaines machines virtuelles.

Longueur 26

Nous pouvons maintenant faire des animations intéressantes

B0 13 CD 10 C4 07 BB 40 01 59 99 89 F8 F7 F3 31 D0 AA E2 F6 26 FE 05 47 EB FA

En assemblée

mov al,13h     ;2b
int 10h        ;2b Enter Video Mode 13h

les ax,[bx]    ;2b Set ES to (roughtly) video memory
mov     bx,320 ;3b Set up  BX asdivisor
pop     cx     ;1b Zeroize CX

start:
cwd            ;1b Sign extend AX to DX, AX will never have the sign bit set so this zeroizes DX in 1 byte
mov     ax,di  ;2b Copy video memory pointer
div     bx     ;2b Divide by width to get AX = Y pos, DX = X pos
xor     ax,dx  ;2b X pos ^ Y pos
stosb          ;1b Store and increment video pointer
loop    start  ;2b CX starts at 0, so this will loop until it wraps around

cycle:
inc     byte [es:di];3b Increment value in video memory to animate
inc     di     ;1b Increment video memory pointer
jmp     cycle  ;2b Infinite loop 

Et la sortie ressemblera à ceci:

La fonction X pos ^ Y pos produit une fractale intéressante, surtout quand elle est animée

Longueur 27

Vous pouvez non seulement générer du texte et des graphiques dans un petit programme .com x86, mais également du son et de la musique:

BA 31 03 B0 3F EE BA 30 03 B0 93 EE B4 01 CD 21 3C 1B EE 3C 1B B0 7F EE 75 EC C3

En assemblée:

    mov dx,0x331            ; value for the midi control port
    mov al,0x3F             ; command value to set midi mode to UART
    out dx,al               ; output the command to the midi control port
play_loop:
    mov dx,0x330            ; value for the midi data port
    mov al,0x93             ; midi instrument value (piano)
    out dx,al               ; output to midi data port
    mov ah,1
    int 0x21                ; read character from stdin, with echo
    cmp al,27               ; test if it is escape
    out dx,al               ; output the ascii value as the midi note to play
    mov al,0x7F             ; note duration
    out dx,al               ; output note duration
    jne play_loop           ; loop if escape was not pressed
    ret  

Ce programme utilise la carte MIDI pour transformer le clavier en piano. Pour ce faire, la carte MIDI est définie sur le mode UART, qui lit les notes MIDI dès leur réception. Ensuite, le programme attend qu'un caractère soit enfoncé et envoie la valeur ASCII sous forme de note à la carte MIDI. Le programme s'exécute jusqu'à ce que vous appuyiez sur échappement.

Longueur 29

Utilisons un système de fonction itéré pour générer une fractale Dragon Curve:

B0 13 CD 10 89 D0 01 CA 29 C1 D1 FA D1 F9 73 03 83 E9 7A B4 01 CD 16 B8 02 0C 74 E6 C3

Traduit en assemblage:

mov  al,13h
start:
int  0x10    ; This does double duty, setting the video mode to 13h at program start,
             ; and calling the 'draw pixel at coordinates' interrupt when looping
mov  ax,dx   ; The next couple instructions are our IFS, the algorithm is aproximately
add  dx,cx   ; f(y) = 0.5x + 0.5y
sub  cx,ax   ; f(x) = 0.5x - 0.5y OR f(x) = 0.5x - 0.5y - 1
sar  dx,1    ;
sar  cx,1    ;
jnc  skip    ; This jump handles pseudo-randomly switching between the two functions for x,
             ; based on if the previous value of x was odd or not.
sub  cx,122  ; Magic number, chosen since it provides sufficent 'randomness' for a filled in
             ; fractal and a good scale to the fractal. 102 and 130 also work.
skip:
mov  ah,1
int  0x16    ; Get keyboard state, zero flag will be set if no key has been pressed
mov  ax,0xC02; Set up AH for the draw pixel function when int 0x10 is executed,
             ; AL = color, CX = column, DX = row
jz   start   ; Loop if a key hasn't been pressed
ret  

Sortie:

En appuyant sur une touche de non-contrôle, le programme quittera. Ceci est basé sur Fire Coral de Desire sur Pouet.net.

Longueur 52

Ce programme est un peu une double fonctionnalité, il montre un peu du co-processeur à virgule flottante x87 et du code à auto-modification.

B3 07 D9 E8 B1 11 DE 0E 32 01 E2 FA BE 0A 24 56 B1 09 DF 34 AC D4 10 
86 E0 05 30 30 50 E2 F5 44 B4 2E 50 89 E2 B4 09 CD 21 FE 06 03 01 4B
75 D2 CD 20 0A 00

Lorsqu'il sera exécuté, le programme générera plusieurs constantes mathématiques:

1.00000000000000000
3.32192809488736235
1.44269504088896341
3.14159265358979324
0.30102999566398120
0.69314718055994531
0.00000000000000000

Il s'agit de One, Log2 (10), Log2 (e), Pi, Log10 (2), Log e (2) et Zero.

En assemblée:

org 100h

mov     bl,7         ;Counter for the total number of constants to print
start:
fld1                 ;Floating point constant to load on the FP stack,
                     ;start with 1 since it's op-code is the lowest

mov     cl,17        ;Multiply the constant by 10, 17 times to get the
mult:                ;printing part as an integer
fimul   word[ten]
loop    mult

mov     si,10+'$'*256;ASCII new line (10) and the end-of-string ($)
                     ;characters. These are used both as
push    si           ;a constant memory location, and stored to the
                     ;stack to format and printing

mov     cl,9         ;print 18 digits (9 pairs)
fbstp   [si]         ;store the integer part of the floating point
                     ;number on top of the FP stack as a packed
                     ;binary-coded decimal number (1 digit/nibble),
                     ;and then pop the number off the FP stack

convert:
lodsb                ;load a pair of packed digits

db 0xd4,16 ; AAM 16  ;ASCII Adjust For Multiply instruction using
                     ;non-standard base 16. This puts AL/16 in AH,
                     ;and AL%16 in AL, unpacking the digit pair.

xchg    ah,al        ;Swap the digit order
add     ax,'00'      ;Convert the digits to ASCII values
push    ax           ;Store digits on the stack
loop    convert

inc     sp           ;AX now holds the 1st 2 digits to print,
mov     ah,'.'       ;so to insert a decimal point, the 2nd digit
push    ax           ;is replaced with a '.', the stack pointer
                     ;is adjusted to overwrite 1 byte, and then
                     ;AX is pushed on the stack

mov     dx,sp        ;Load DX with the start of the print string
mov     ah,9         ;Load AH with the 'Print String' constant
int     21h          ;Call the 'Print String' interrupt to display
                     ;the constant

inc     byte[start+1];Self-modifying code - increment the load
                     ;floating point constant op-code to iterate
                     ;through all of them

dec     bx
jnz     start        ;Exit when all 7 constants have been printed
int     20h


ten: dw  10

Le calcul mathématique en virgule flottante sur les systèmes x86 était à l’origine géré par le co-processeur facultatif x87; Le x87 avait aussi une architecture assez différente, il était basé sur une pile, avec 8 registres de 80 bits disponibles. Il disposait également de divers modes d'arrondi, de précision et d'exceptions pouvant être masquées pouvant être définies.

Ce programme imprime les valeurs de sept constantes intégrées dans les processeurs. Il peut sembler étrange que l’espace d’instruction soit gaspillé avec des constantes simples telles que 0 et 1, mais gardez à l’esprit que le jeu d’instructions a été créé lorsque la mémoire était petite et que ces instructions ont généralement une taille inférieure de 2 octets à celle d’opérations équivalentes. Le programme utilise également une instruction obscure, FBSTP -'Store BCD Integer et Pop '. À l'époque du développement du x86, les opérations sur les nombres BCD étaient plus courantes et le x86 / x87 contient plusieurs instructions destinées à simplifier les calculs BCD, telles que l'instruction AAM 'ASCII Adjust for Multiple' également utilisée dans le programme.

Dans le modèle de mémoire non protégé utilisé par les premiers programmes x86, il n'y avait pas de distinction entre données et code. De ce fait, il est facile de parcourir les instructions «Load Constant» codées séquentiellement en incrémentant simplement la valeur appropriée.

Longueur 64

En même temps que je postais pour le Mandelbrot Challenge , il est possible d’écrire un programme qui affiche une fractale de 320 x 200 couleurs de Mandelbrot en seulement 64 octets.

B0 13 CD 10 C4 07 99 89 F8 B9 40 01 F7 F1 83 E8 64 FE CE 31 DB 31 F6 
89 F5 0F AF F3 01 F6 0F AF DB 70 19 0F AF ED 70 14 01 EB 70 10 29 EB
29 EB C1 FB 06 01 D3 C1 FE 06 01 C6 E2 DB 91 AA EB C6

En assemblée:

mov al,13h ; set up graphics mode 13
int 10h

les ax,[bx]; trick to set video memory

FillLoop:
cwd
mov ax,di  ; di is the current position on screen
mov cx,320 ; convert di int x,y screen coordinates
div cx     ; CX is the iteration counter, exit the loop if it hits
           ; zero before the value escapes.
sub ax,100 ; center the fractal vertically
dec dh     ; center the fractal horizontally

xor bx,bx
xor si,si

MandelLoop: ; Fairly standard Mandelbrot routine,
mov bp,si   ; exits if the values overflow
imul si,bx
add si,si
imul bx,bx
jo MandelBreak
imul bp,bp
jo MandelBreak
add bx,bp
jo MandelBreak
sub bx,bp
sub bx,bp

sar bx,6   ; We use fixed point math with the lowest 6
add bx,dx  ; bits being the fractional portion, so this
sar si,6   ; rescales the values after multiplication
add si,ax

loop MandelLoop

MandelBreak:
xchg ax,cx ; Write the escape itteraction as the color
stosb
jmp FillLoop

Le résultat final est cette image:

Ce programme utilise des mathématiques en virgule fixe pour générer la fractale, car il prend moins d'octets. Les 6 bits les plus bas des registres de 16 bits sont considérés comme la partie fractionnaire du nombre et les valeurs sont redimensionnées après avoir été multipliées.

Haskell

Vous voudrez peut-être lire de bas en haut. Parfois, je me réfère aux extraits inférieurs, mais jamais aux extraits supérieurs, cela peut donc aider à comprendre.

Les lecteurs qui ne connaissent pas Haskell: est-ce que je suis clair? Quand est-ce que je ne suis pas clair? Je ne peux pas dire.

Longueur 86 extrait

Une instance pliable pour notre arborescence de données (extrait 23). Foldable est une classe de types - comme dans une classe (/ groupe) de types. Celles-ci sont parallèles aux interfaces en Java. Ils généralisent essentiellement des types, des types unificateurs qui ont des caractéristiques communes; par exemple, ils peuvent être additionnés ( Monoid), containers ( Functor), imprimés en texte ( Showque nous avons déjà rencontrés dans la showfonction), etc. Celui-ci unifie les types de données qui ressemblent à des listes en ce sens qu'ils peuvent être itérés ou aplatis à une liste.

Dans cet extrait de code, nous définissons l'instance en définissant foldr, qui effectue essentiellement une itération sur le type de données de droite à gauche. Maintenant, nous pouvons utiliser un tas de code général pré-écrit. Tout d' abord, nous définissons une fonction d'aide pour obtenir un arbre singleton, pour éviter tout le désordre: s a = N E a E. Maintenant:

sum (N (s 3) 7 (N E 5 (s 8))     === 23
product (N (s 3) 7 (N E 5 (s 8)) === 840
toList (N (s 3) 7 (N E 5 (s 8))  === [3,7,5,8]

etc.

Voici une photo de notre arbre:

7
| \
3  5
    \
     8

Longueur 70 extrait

primes=sieve[2..] where
 sieve(p:xs)=p:sieve(filter(\x->x`mod`p/=0)xs)

C'est un tamis de premier choix!

(note: /=est ce qui !=est dans d'autres langues)

Cela fonctionne en définissant une fonction sievequi filtre la liste et ne conserve que les nombres non divisibles par aucun nombre premier précédent. Il est défini de manière récursive - à sieveest défini comme pour diviser la liste à un premier élément pet une queue, le filtre de la queue tout nombre divisible par p, sievele bit restant, fixer ple début de cela, et le retour.

Encore une fois, nous travaillons ici avec des listes infinies - mais le calcul s’arrêtera dans le temps tant que vous n’aurez pas besoin d’un nombre infini de nombres premiers pour être calculés.

take 4 primes === [2,3,5,7]

Longueur 68 extrait

Enfin, une quine!

main=do putStr s;print s where s="main=do putStr s;print s where s="

En lisant ceci pour la première fois, vous pourriez penser que les guillemets manquaient dans la sortie de cette page, et pourquoi voudriez-vous écrire putStrune fois et une fois print? Cela sonne pareil.

En Haskell, putStrest une fonction qui n’imprime que le contenu de la chaîne reçue par stdout; print, cependant, imprime les choses sur la sortie standard. Donc, print 4est équivalent à putStr "4\n", mais putStr 4est absurde - 4n'est pas une chaîne! Ainsi, quand printobtient une valeur, il la convertit d'abord en une chaîne, puis imprime cette chaîne. Généralement, le moyen de convertir des éléments en chaînes consiste à trouver la manière dont vous l'écrivez dans le code. Ainsi, la façon dont vous écrivez la chaîne abcdans une chaîne en code Haskell est la suivante "abc": vous print "abc"imprimez donc "abc", pas abc.

_{Quelle chance j'ai assez de voix maintenant, je n'aurai pas à jouer au golf avec ces choses}

Longueur 33 extrait:

main=go 0
go n=do print n;go(n+1)

La chose importante à noter est que nous n’avons pas utilisé de boucle. Haskell ne boucle pas. Haskell récidive. Haskell n'a pas de boucles. C'est plus profond que ça: Haskell n'a même pas de flux de contrôle . Comment, vous pourriez demander? Eh bien, il n'en faut pas.

Avec les détails Ce programme imprime une suite d’entiers croissante, infinie, à partir de 0. Il les goimprime à partir de son entrée, puis l’ mainappelle 0.

doest un pouvoir syntaxique spécial de Haskell. Dans ce scénario, il combine simplement les actions d'E / S, comme le >>fait le cas (voir l'extrait 22).

Longueur 26 extrait:

map f=foldr(\x y->f x:y)[]

Ceci définit la mapfonction, probablement familière à tout le monde, utilisant foldr. Notez que bien que nous n’ayons pas déclaré maple type, l’ordinateur sait en quelque sorte que son type est (a -> b) -> [a] -> [b], c’est-à-dire qu’une fonction de ato bet une liste de as renvoient une liste de bs.

Comment a-t-il su? ;-)

Longueur 25 extrait:

main=putStr"Hello World"

La norme Hello World. Notez les types: maina type de IO ()et putStra type de String -> IO ()(une fonction des chaînes aux actions d'E / S qui ne renvoient rien).

Longueur 23 extrait:

data T a=E|N(T a)a(T a)

Ceci est une définition standard d'un arbre. Combien plus facile que toutes ces lignes nécessaires pour définir une arborescence en Java, C ou quoi que ce soit d'autre.

(voir l'extrait 10)

Décomposons:

data- cette déclaration déclare un type de données. T a- un arbre contenant des éléments de type a. C'est le type que nous définissons. =- chaque valeur de T asera l'une des valeurs suivantes, séparées par un tuyau |. E- une des valeurs possibles de T s- l'arbre vide. N (T a) a (T a)- l'autre valeur possible d'un arbre - un nœud. Chaque nœud est composé de l'enfant de gauche ( (T a)), de l'élément ( a) et de l'enfant de droite ( (T a)).

Longueur 22 extrait:

main=putStrLn"y">>main

Une yesfonction Haskell . >>est un opérateur qui combine et séquence deux actions d'E / S. Il a le type de >> :: IO a -> IO b -> IO b.

mainest défini récursivement par lui-même, comme l’action I / O qui imprime d’abord "y"puis fait ce qu’elle mainfait.

Longueur 18 extrait:

fix f=r where r=f r

Une meilleure définition pour fix. (Voir l'extrait 14.) Le problème avec la première définition, fix f = f(fix f)est que chaque fois que nous appelons des fix f fixrappels fix f, nous nous souvenons fix f, générant des copies sans fin du même calcul. Cette version le corrige en définissant r(result) comme étant le résultat; en tant que tel f r = r,. Alors, définissons r = f r. Maintenant nous revenons r.

Longueur 17 extrait:

f n=product[1..n]

C'est la manière fonctionnelle de définir factorielle.

Longueur 16 extrait:

f n=(\x->x+x+x)n

(\x -> x + x + x)est un lambda (une pensée \ressemble à la lettre.).

(\x -> x + x + x) nest le lambda appliqué à n(c'est exactement la même chose que n + n + n).

fest la fonction multiplier par trois (aussi f = (*3))

Longueur 15 extrait:

sum=foldl (+) 0

Ceci définit la sumfonction en utilisant un pli. Un repli est essentiellement une boucle sur les éléments d'une liste avec un seul accumulateur.
foldlprend comme argument une fonction fet une valeur initiale xpour l'accumulateur et une liste xs. La fonction fdoit obtenir en entrée la valeur de l'accumulateur précédent et la valeur actuelle de la liste, puis renvoie l'accumulateur suivant.
Ensuite, le pli itère sur les valeurs de la liste, s’appliquant fsur l’accumulateur précédent, puis renvoie le dernier accumulateur.

Une autre façon de penser aux plis est comme le pli "insère" fentre les valeurs de la liste et avec l'accumulateur initial sur l'un des côtés. Par exemple, foldl (*) 1 [4,2,5]évalue à 1 * 4 * 2 * 5.

Longueur 14 extrait:

fix f=f(fix f)

Le ycombinateur. Il est généralement nommé fixcar il trouve le point de fixation de l'équation f x = x. Notez que cela x = infinite looppeut aussi parfois être une solution, donc fix (\x -> x^2 + 5*x + 7)ne résoudra pas l'équation x^2 + 4*x + 7 = 0mais renverra une boucle infinie.

Vous pouvez également noter que la x = infinite loopsolution n’est pas toujours à cause de la paresse de Haskell.

Cette version est une fuite de temps et d'espace; nous allons le redéfinir dans un extrait plus long.

Longueur 13 extrait:

f=sum.map(^2)

Ceci définit la fonction f qui donne à une liste la somme de ses carrés. Elle est la fonction composition de la fonction sum et de la fonctionmap(^2) , qui est à son tour la fonction map appliquée à la fonction (^2) (la fonction carrée ), qui est à son tour une section de la fonction (les sections ont été introduites à l'extrait 2 et la composition à l'extrait 3). ). ^

Comme vous pouvez le constater, les fonctions sont très importantes dans un langage fonctionnel comme Haskell. En fait, il a été dit que Haskell est le langage avec les fonctions de bibliothèque les plus standard qui obtiennent des fonctions en tant qu'entrées ou des fonctions de retour en tant que sorties (ce qui est communément appelé une fonction d' ordre supérieur .

Soit dit en passant, sur le plan technique, tous les deux ou argument supplémentaire fonction est une fonction qui renvoie des fonctions comme sorties (ce qui est appelé curryfication).

Longueur 10 extrait:

data B=T|F

Ceci est une définition des booléens Haskell avec des noms différents. Le type booléen est nommé B.
Cette définition introduit deux constructeurs: true ( T) et false ( F).
Cet extrait de code indique essentiellement le compilateur que chaque booléen ( B) est true ( T) ou faux ( F), ou en d' autres termes, B=T|F.

En fait, tous les types de données peuvent jamais être définis dans Haskell, alors que dans d'autres langages, les types de données number, reference et array nécessitent une prise en charge spéciale du compilateur. Dans la pratique, Haskell prend en charge les utilisateurs car cela serait très pratique sinon, le Booltype de données est défini entièrement en langage.

Longueur 9 extrait:

main=main

Ce programme insensé va définir mainêtre principal. Parce que Haskell est paresseux, les valeurs qui nécessiteraient une boucle infinie à évaluer peuvent être utilisées librement si nous n'utilisons pas leur valeur réelle. Ces valeurs qui contiennent des boucles infinies, comme la nôtre main, sont appelées "bas".

Un fait amusant est que le compilateur GHC Haskell peut détecter ces types de boucles infinies et émettre une exception capturable (!) Lorsqu’il est exécuté.

Longueur 8 extrait:

f(x:_)=x

Ceci définit la fonction fqui, étant donnée une liste non vide, retournera sa tête.

Les modèles dans Haskell ressemblent au processus de décompression de séquence de Python, mais généralisé pour tous les types. Les modèles peuvent rejeter ou correspondre à une valeur et, si elle correspond, lier des variables à des valeurs.

Les motifs de cet extrait sont les suivants:

• _: le motif qui correspond à rien et ne lie aucune variable.
• x: le motif qui lie n'importe quoi et le lie à la variable x .
• :: ce motif touche les motifs enfants, c’est-à-dire un pour la tête et un pour la queue. Si la liste n'est pas vide, elle leur correspond avec la tête et la queue.

La correspondance de modèle est très généralisée. En fait, la simple définition de nouveaux types de données introduira automatiquement des modèles pour travailler avec eux.

Longueur 5 extrait:

x=2:x

Whoa, il y a tellement de choses à expliquer sur celui-ci.

Tout d'abord, Haskell est paresseux. Cela signifie que les sous-expressions ne seront évaluées que lorsque cela sera strictement nécessaire.

Remarque: cet extrait de code ne montre pas l'affectation, mais la définition. Haskell n'a pas de mission.

Cet extrait de code définit xune liste infinie entièrement composée de 2. Habituellement, dans d'autres langues, xil faut évaluer avant de 2:xpouvoir être évalué, mais en Haskell, nous pouvons le faire.

Les listes infinies Haskell sont en quelque sorte un mélange d'itérateurs et de listes chaînées: elles agissent comme les deux (une itération sur une plage utilisera une mémoire constante, par exemple).

Longueur 4 extrait:

2:[]

Cet extrait code simplement la liste de singleton [2]. :est l’ opérateur Cons à Haskell. En fait, la syntaxe de liste régulière est simplement un sucre syntaxique pour l'opérateur cons et le littéral de liste vide. Ceci est étroitement lié à la manière dont Haskell traite les types de correspondance de modèle et de données (en particulier le concept de constructeur).

Longueur 3 extrait:

f.g

En Haskell, .signifie composition des fonctions. Haskell peut être écrit dans un style "sans point", qui se caractérise par le fait de ne pas nommer les arguments de la fonction et d'utiliser le. opérateur pour manipuler le flux de données.

Longueur 2 extrait:

1-

Lorsque ce code est placé entre parenthèses (pour des raisons syntaxiques), il est appelé une "section". C'est alors une fonction qui donne un certain nombre, "remplit" la tache vide et renvoie un moins ce nombre. Cette notion est parfois utile dans un langage fonctionnel comme Haskell, où sinon un lambda serait nécessaire.

Longueur 1 extrait:

1

Dans Haskell, 1peut être à la fois Int, Float, Double, Wordet ainsi de suite. En fait, vous pouvez écrire du code pour définir une version de 1n’importe quel type et l’utiliser librement.
cela se fait aussi en JavaScript, Python, etc., mais contrairement à ceux-ci, cela se fait en toute sécurité.

factoïde:

À l'origine, le comité Haskell avait l'intention d'appeler la langue "Curry" après le nom de Haskell B. Curry, mais a décidé de changer le nom en Haskell car des jeux de mots pourraient être générés. Ce n'est que plus tard qu'ils ont remarqué la similitude de Haskell avec "Pascal" et "Hassle"!

C #

C # est un mélange amusant et fou de fonctionnalités de Java, C, Haskell, SQL et de nombreux autres langages. Il fournit de nombreuses fonctionnalités et API vraiment agréables. Il est également connu ici pour être assez verbeux, mais nous verrons ce que nous pouvons faire!

Je vais ignorer le passe-partout habituel:

class Program { public static void Main(string[] args) { ... } }

Longueur 1:

;

Les commandes se terminent par des points-virgules en C #! Une ligne vide est une syntaxe parfaitement valide.

Longueur 5:

x=5f;

Lorsque vous spécifiez des nombres littéraux en C #, le compilateur supposera qu'il s'agit d'ints ou de doubles (selon qu'ils ont ou non un point décimal). Si vous souhaitez utiliser un float littéral, vous devez le spécifier en ajoutant "f" au nombre, ou il sera lancé au moment de l'exécution, ce qui entraînera un léger coût.

Longueur 7 (octets):

s=@"
";

Si vous préfixez un littéral de chaîne avec un signe @, il devient un littéral de chaîne "textuel". Les littéraux de chaîne normaux analysent les séquences d'échappement telles que '\ n' dans des caractères spéciaux, mais pas les littéraux, ce qui vous permet d'utiliser le caractère barre oblique inversée sans l'échapper. Ils peuvent également inclure des retours à la ligne, comme indiqué. Cela pourrait vous faire économiser quelques octets dans le golf ou rendre vos littéraux de chaînes multilignes plus lisibles. Faites juste attention à l'indentation étant incluse dans la chaîne.

Longueur 8:

()=>x=y;

Cette expression est une fonction anonyme. Il retourne un objet de type Actionqui peut être transmis et appelé comme une fonction. Les fonctions anonymes héritent de la portée dans laquelle elles ont été déclarées, et elles extraient avec elles les variables locales de cette portée où qu'elles aillent.

Longueur 9:

(a)=>a.p;

Voici une autre fonction anonyme qui utilise un paramètre et une valeur de retour. L'expression retourne un objet de type Func(le Func lui-même renvoie le type de a.p. Vous utiliserez Funcbeaucoup pour vous connecter à Linq.

Longueur 10:

enm.Any();

Ceci est notre première introduction à Linq! Linq est un ensemble de méthodes d'extension pouvant être appelées sur tout objet énumérable (implémentant l'interface IEnumerable) - comme Arrayet List. IEnumerable emploie une évaluation paresseuse: il parcourt la collection, un élément à la fois, sans connaître la collection dans son ensemble - il pourrait même être infini!

C'est là qu'intervient Any- il retourne truesi Enumerable contient au moins 1 élément. Bien mieux que de calculer toute la longueur.

Longueur 11:

var a=1.5f;

Le varmot-clé indique au compilateur de déterminer automatiquement le type de fichier a. adans ce cas, sera tapé comme Single. Très pratique pour le code de golf, car il est de loin plus court que presque tous les types, bien que beaucoup n’aiment pas l’utiliser dans le code de production.

Longueur 15:

yield return 0;

Voici une déclaration folle que vous connaissez peut-être moins bien. Vous savez que les objets peuvent être énumérés en héritant de IEnumerable, mais saviez-vous que les fonctions peuvent être énumérées? Déclarez une fonction avec un type de retour de IEnumerableet possédez- yield returnla autant de fois que vous le souhaitez. Lorsque vous obtenez un énumérateur à la fonction, chaque appel auquel GetNextle programme exécute tout le code yield return, renvoie la valeur, puis se met en pause jusqu'à ce que vous le fassiez avancer. Vous utilisez yield breakpour mettre fin à l'itération.

Longueur 16:

[Obsolete]int a;

Cet extrait montre un attribut. Un attribut est une sorte de tag que vous pouvez coller sur n'importe quelle déclaration de votre code. Certains demandent au compilateur de faire certaines choses, comme celle-ci qui émet un avertissement Obsolète si vous appelez a. Vous pouvez créer les vôtres en les étendant Attributeet les interroger à l'aide de Reflection (peut-être plus à ce sujet plus tard). Vous pouvez utiliser des méta et limiter le type de déclaration sur lequel un attribut peut être utilisé avec cet AttributeUsageattribut.

Longueur 17

c.Count(t=>t==3);

Voici une méthode de golf pratique. Étant donné un Funcqui associe un élément du dénombrable cà bool, il renvoie le nombre d'éléments cpour lesquels qui Funcretourne true. Beaucoup plus agréable que d'écrire une boucle.

Longueur 18:

foreach(T t in c);

Ceci est une boucle pour chaque. Avec toutes ces discussions sur les choses énumérables, il s’agit d’une structure indispensable. foreachC'est un sucre syntaxique qui va créer un énumérateur c(qui doit être énumérable) et le parcourir un élément tà la fois. Vous pouvez modifier ou examiner chaque élément individuel, mais la modification de la collection elle-même invalidera l'énumérateur.

Longueur 19

c.Select(t=>t.a/2);

Ceci est votre fonction "carte", pour les fans de programmation fonctionnelle. Select est une manière concise de réaliser une conversion arbitraire (définie par un Funcpassé) sur chaque élément d'un énumérable. Il retourne un IEnumerable qui crachera les éléments "convertis" lorsque vous l'itérerez.

Longueur 21

Console.Write("Hi!");

Cette ligne écrit du texte sur stdout, et est probablement l'une des principales raisons pour lesquelles C # n'est pas beaucoup utilisé pour le golf!

Longueur 23

typeof(T).GetMethods();

C # prend en charge une fonctionnalité très puissante appelée réflexion. Reflection vous permet d'examiner la structure de votre code au moment de l'exécution. Par exemple, cet appel renverra un tableau de toutes les méthodes du type spécifié. Vous pouvez examiner ces méthodes, les appeler ou même modifier les valeurs des champs et des propriétés. Les attributs (voir Longueur 16) constituent un bon moyen de baliser des parties de votre code à utiliser avec Reflection.

Longueur 25

from t in c select t.a/2;

Est-ce que SQL? En code C #? Assez proche. Cette expression fait la même chose que celle de longueur 19.

Longueur 27

for(var l;;l=new object());

C # est un langage mal placé, ce qui signifie que toute mémoire allouée (à l'aide du newmot - clé) peut être libérée automatiquement tant qu'aucune référence à ce mot n'existe. Ce code fonctionnera heureusement pour toujours même si je n'ai jamais explicitement libéré la mémoire créée. La collecte des ordures a des coûts, cependant - recherchez sur le Web pour en savoir plus.

Longueur 29

var e=Enumerable.Range(0,99);

Enumerable.Rangeest une fonction de golf potentiellement utile. Il retourne une structure qui peut être énumérée et donnera chaque nombre dans la plage spécifiée, dans l'ordre. Le deuxième paramètre est un compte, pas un index.

Longueur 31

public int pr{get;private set;}

Ici, nous pouvons montrer une simple "propriété", une fonctionnalité POO et une autre caractéristique du C #. Si vous avez déjà utilisé Java, vous avez probablement créé des méthodes 'get' et 'set' pour un champ afin de séparer leur accessibilité ou d'exécuter du code lorsqu'il est modifié. Eh bien, C # vous permet de déclarer ce code directement en haut du champ et de définir des modificateurs d'accès distincts pour obtenir et définir. Cet extrait de code crée automatiquement un getter et un setter par défaut, mais rend le setter privé.

Longueur 32

public static void m(this T o){}

Cet extrait présente une fonctionnalité C # intéressante pour la conception d'API. En appliquant le thismodificateur au premier paramètre d'une méthode statique, cette méthode devient une méthode "d'extension". Une fois que cela est déclaré, vous T.mpouvez maintenant appeler n'importe quel objet de type T comme s'il s'agissait en réalité d'une méthode T. Cela permet d'ajouter de nouvelles fonctionnalités à toute classe existante, sans modifier ni même accéder à son code source.

Longueur 38

int f(int a,ref int b,out int c){c=0;}

Cette méthode présente différents types de passage de paramètres que vous pouvez avoir en C #. Les paramètres non modifiés sont passés par valeur . Les paramètres préfixés par refsont passés par référence: vous pouvez leur affecter un nouvel objet et ils le reporteront hors de la méthode. Les paramètres précédés de préfixes outsont comme des valeurs de retour supplémentaires: vous devez leur attribuer une valeur dans la méthode, et elles sont renvoyées comme des paramètres ref.

Longueur 42

Console.Write("It is \{DateTime.Now()}.");

La nouvelle norme C # 6 peut vous faire économiser certains caractères lorsque vous devez générer des chaînes assemblées, en utilisant une interpolation de chaîne. Cette fonctionnalité vous permet d'écrire n'importe quelle expression entre accolades dans un littéral de chaîne. La chaîne sera automatiquement assemblée avec les valeurs de ces expressions au moment de l'exécution.

Longueur 48

IEnumerable f(){for(int a=0;;)yield return a++;}

Juste assez de personnages maintenant pour faire quelque chose avec un but réel! Cette méthode utilise certaines des idées que nous avons explorées ci-dessus pour créer un Enumerable infini qui renverra simplement les entiers, un par un, en commençant par 0. N'oubliez pas que C # utilise une évaluation paresseuse avec Enumerables, ainsi une séquence infinie est parfaitement valide - vous pouvez répétez autant de séquences que vous le souhaitez et sortez à tout moment.

Longueur 56

int p{get{return mP;}set{mP=Math.Max(value,0);}};int mP;

Voici un autre exemple de "propriété" (voir l'extrait 31). Ici, j'ai en fait défini différents extraits de code pour getet setplutôt que d'utiliser les extraits automatiques comme auparavant. Cet exemple montre comment utiliser une propriété pour valider la valeur affectée à une variable. Dans ce cas, la valeur ne doit pas devenir inférieure à 0. Une autre bonne utilisation des propriétés consiste à notifier un événement lorsqu'une valeur est modifiée ou à reconstruire des valeurs en cache. cela pourrait être basé sur celui-ci.

Longueur 65

int v;public static implicit operator int(Program o){return o.v;}

Cette fonctionnalité s'appelle une distribution implicite. C'est un peu comme une méthode d'extension en ce sens que c'est un code statique qui opère sur une classe spécifique (voir l'extrait 32). Cependant, la conversion implicite n'est pas utilisée en l'appelant, mais simplement en traitant un Programobjet comme un entier (par exemple int i=new Program()). Lorsque vous effectuez cette opération, l'objet est automatiquement converti dans le type sous lequel vous l'utilisez, en fonction du code de la conversion implicite. La meilleure pratique consiste à ne le faire que lorsqu'aucune information n'est perdue à la suite de la conversion.

Java

Longueur 44 extrait

Object a=System.out.append("Hello, World!");

Imprime Hello, World!sur STDOUT.

Longueur 43 extrait

float[][][][][]a=new float[5][3][7][2][10];

acontient 10 matrices contenant chacune 2 matrices contenant chacune 7 matrices contenant chacune 3 matrices contenant chacune 5 floats.

Longueur 42 extrait

interface A{static void main(String[]a){}}

Un programme complet. Puisque tout dans un interfaceest inhérent public, nous pouvons omettre le mot publicde la méthode principale.

Longueur 36 extrait

class A{class B extends A{B.B.B b;}}

Aa une classe intérieure B. Cela signifie que nous pouvons déclarer une variable de type A.B.

Mais Best une sous-classe de A, ce qui signifie qu'il a toutes les méthodes, les champs et les classes internes de A. Ainsi, nous pouvons également faire référence au type B.B.

Dans ce code, nous allons plus loin et donnons Bune variable d'instance de type B.B.B.

La morale: suivre les questions brûlantes sur SO peut vous apprendre beaucoup de techniques intéressantes, bien qu’inutiles.

Longueur 35 extrait

l.stream().map("a"::equals).count()

Si lest une liste de chaînes, cela nous indique combien d’entre elles sont égales "a".

Longueur 34 extrait

public static void main(String[]a)

Méthode signature de la méthode principale d'un programme. Juste 11 autres personnages et nous pouvons faire un programme complet!

Longueur 33 extrait

enum D {NORTH, EAST, SOUTH, WEST}

NORTH, EAST, SOUTHEt WESTsont toutes les constantes de type D.

Longueur 32 extrait

Files.readAllBytes("hello.txt");

Lit un fichier entier en renvoyant un byte[]contenu.

Longueur 31 extrait

new String(new char[]{'h','i'})

Équivalent à "hi". Utile si la "clé est cassée.

Longueur 30 extrait

new JFrame().setVisible(true);

Crée un nouveau cadre visible dans lequel vous pouvez placer d'autres composants.

Longueur 29 extrait

throws ClassNotFoundException

Force toutes les méthodes qui appellent cette option pour utiliser un try- catchbloc, ou bien passer l'erreur la pile. Les exceptions vérifiées sont l’une des décisions les plus controversées des concepteurs Java.

Longueur 28 extrait

int f(int x){return f(x-1);}

Cette fonction ne fonctionne pas pour toujours; en fait, sur un ordinateur typique, cela prend moins d'une seconde. Merci, débordement de pile.

Longueur 27 extrait

Object a=new String[]{"a"};

Crée un nouveau tableau de chaînes.

Longueur 26 extrait

Object.class.newInstance()

Crée un nouveau Object.

Longueur 25 extrait

((Supplier)()->-~0).get()

Il est préférable d'éviter les constantes de codage en dur. C'est un moyen orienté objet d'obtenir la valeur 1sans utiliser de constantes autres que 0.

Longueur 24 extrait

(Function<Long,?>)x->x+1

La fonction successeur.

Longueur 23 extrait

l.removeIf(x->x%10==0);

Si lest une liste d'entiers, cela supprime toutes les valeurs divisibles par 10.

Longueur 22 extrait

int i=(new int[7])[5];

Crée un nouveau tableau de sept entiers et obtient le cinquième élément.

Longueur 21 extrait

Arrays.asList(2L,"a")

Crée une liste de tableaux avec ces éléments.

Longueur 20 extrait

System.out.print(s);

Impressions s.

Longueur 19 extrait

import java.util.*;

Permet l' utilisation concise des classes comme List, Map, Scanner, Timeret Random.

Longueur 18 extrait

Math.addExact(x,y)

Ajoute deux entiers xet y. En cas de dépassement de capacité, la méthode lève une exception plutôt que de donner une réponse incorrecte.

Longueur 17 extrait

Double.MIN_NORMAL

La plus petite valeur positive de type double, où le premier bit du significande est 0.

Longueur 16 extrait

System.in.read()

Lit un seul caractère de la console.

Longueur 15 extrait

Long.reverse(x)

Inverse les bits dans la représentation binaire de x.

Longueur 14 extrait

int x=050+120;

xest maintenant 160, puisque tout ce qui commence par 0est traité comme octal.

Longueur 13 extrait

private C(){}

Un constructeur privé empêche les autres classes de l'instancier. Ce modèle est utilisé par les classes Systemet Math, entre autres. Un constructeur privé peut également être utilisé pour appliquer le modèle Singleton.

Longueur 12 extrait

static class

Permet la création de classes internes sans classe externe englobante - une solution à un problème rencontré par de nombreux programmeurs .

Longueur 11 extrait

throw null;

Il est souvent nécessaire de lancer un NullPointerException, mais c'est aussi assez verbeux. C'est une alternative beaucoup plus simple.

Longueur 10 extrait

int[]a,b[]

Définit deux variables: aet b. aest de type int[]et best de type int[][].

Longueur 9 extrait

switch(x)

Va à un endroit, en fonction de la valeur de x.

Longueur 8 extrait

break a;

Sort du bloc étiqueté a.

Longueur 7 extrait

goto x;

Le gotomot clé est réservé en C, C ++ et Java. Si xest une étiquette, ce code envoie le programme à l'étiquette appropriée - en C et C ++. Mais c'est Java, ça déclenche un mystérieux RuntimeException. En fait, il n’ya aucun moyen d’utiliser le gotomot clé en Java.

Longueur 6 extrait

\u003b

Termine une déclaration. Java est bizarre .

Longueur 5 extrait

a-=-a

Double aen soustrayant sa négation.

Longueur 4 extrait

a&=b

Définit la valeur de abit à bit et de aet b.

Longueur 3 extrait

...

N'importe quel nombre d'arguments, consolidés dans un tableau.

Longueur 2 extrait

<>

Permet au compilateur de déterminer quel type générique vous voulez probablement dire. Très un-Java-like.

Longueur 1 extrait

@

Indique une annotation permettant d'afficher des informations supplémentaires sur les méthodes et les classes.

Factoïde

En Java, les boucles infinies provoquent parfois des erreurs de compilation. Par exemple, la boucle while(true);ne peut pas être terminée sans quitter la méthode. Par conséquent, tout code subséquent déclenchera une erreur "instruction inaccessible". Comme @Optimizer l'a fait remarquer, seules certaines boucles infinies seront capturées de cette façon.

Python

Commençons maintenant par les plus récents pour votre commodité! Pour lire la longueur 30 en commençant par la plus ancienne, accédez à l'historique des révisions.

Si quelqu'un a des suggestions, n'hésitez pas à commenter.

Longueur 52:

i=0
while s[i-n:]:print(' '*n+s)[i:n+i];i+=1;i**7**7

Tiré de mon inscription au défi Fake Marquee Text . set ndoivent être définis à l'avance sur une chaîne et un entier. En fait, cela ne fonctionne pas bien dans l’interprète gratuit Python 2 que j’utilisais, alors j’ajoute des parenthèses (' '*n+s)[i:n+i]et vous pouvez le voir s’exécuter dans l’interprète Python 3 ici .

Longueur 43:

#-*-coding:rot13-*-
cevag h"Una fubg svefg"

En Python, vous pouvez coder la source avec un codec spécifique. Cela montre comment le source peut être écrit dans Rot13. La syntaxe générale est la suivante: # -*- coding: <codec-name-goes-here> -*-.

Ici c'est traduit:

#-*-coding:rot13-*-
print u"Han shot first"

Le uspécifie que le littéral de chaîne suivant est une chaîne Unicode. Cela est nécessaire si vous voulez que vos chaînes soient également dans Rot13, sinon chaque chaîne du source est facilement lisible malgré le cryptage. Alternativement, vous pouvez utiliser .encode("Rot13")après chaque chaîne (n'oubliez pas d’utiliser Rot13 sur ceci aussi.) cet article , certains codages alternatifs sont «base64», «uuencode», «zlib» ou «bz2».

Longueur 33:

import cmath
print cmath.sqrt(-1)

C'est le module de Python pour les nombres complexes (imaginaires) . Cela imprime 1j, puisque Python est conforme aux normes techniques et utilise jcomme unité imaginaire, bien que je préfère i, qui est plus couramment utilisée en mathématiques, et en utilisant jet ken plus ipour les quaternions , mais je m'éloigne du sujet. Lisez le bug / ordre de changement ici (il ne sera pas changé).

Longueur 30:

f=lambda n:n*f(n-1)if n else 1

Maintenant, nous définissons notre propre fonction factorielle en utilisant la récursivité et le ternaire if-else! Autant que je sache, c'est aussi bien que dans Python. Il pourrait également être écrit de la manière suivante: f=lambda n:n and f(n-1)*n or 1présentant quelques opérateurs booléens de Python (et également en 30 caractères). Voir l'extrait de longueur 15 pour plus d'informations sur la lambdasyntaxe.

Longueur 29:

import math
math.factorial(7)

Trouve la factorielle de 7, en revenant 5040 .

Longueur 25:

import math
print math.pi

Le module mathématique de Python fournit de nombreuses fonctions et constantes utiles. Voici PI. Retours 3.14159265359. (Dans le code ci-dessus, j'ai compté la nouvelle ligne comme un caractère.)

Longueur 24:

f=lambda y:lambda x:x**y

Ceci est un exemple de fermeture. L'appel cube = f(3)fera une fonction cubique qui peut ensuite être appelée avec print cube(24), impression 13824.

Longueur 19:

print"Hello World!"

Enfin, assez de place pour imprimer des impressions de base! L'espace n'est pas requis ici, car les guillemets et les parenthèses sont également des délimiteurs. Cela ne fonctionnera que dans Python 2, car Python 3 a changé la printfonction pour qu'elle s'appelle comme n'importe quelle autre fonction. En Python 3, utilisez print("Hello World!"). Pour plus d'informations sur la fonction d'impression et la différence entre Python 2 et 3, consultez Nouveautés de Python 3.0 .

Longueur 16:

[x*3 for x in l]

Encore une fois, supposons qu’il ls’agit d’une liste ou de tout autre objet itérable, tel qu’une chaîne ou un générateur. Cette déclaration est connue sous le nom de compréhension de liste . C'est beaucoup plus court que d'utiliser la norme pour la structure de boucle. Ici, il retourne une liste avec tous les nombres multipliés par 3. AUSSI, les chaînes peuvent être multipliées!Ainsi, toute chaîne de la liste sera ajoutée (concaténée à elle-même) ce nombre de fois.

Longueur 15:

import this #:)

Il s’agit en réalité d’un extrait de longueur 11, mais j’ai réalisé que j’avais oublié de mettre en valeur (génial) l’ œuf de Pâques de Python ! L’importation de ce module imprime le zen de Python (voir Factoid.) Fait intéressant: le modulethis.py été codé en rot13, ce que j'espère par la suite.

Longueur 14:

lambda x:x**.5

Ceci définit une fonction racine carrée utilisant la lambdasyntaxe de Python pour un littéral de fonction. Les littéraux de fonction en Python ne peuvent contenir que des expressions, pas des instructions. Ce lambda peut être affecté à une variable, transmis à une fonction ou exécuté en ligne avec (lambda x:x**.5)(9), ce qui retourne 3.0. L'utilisation d'exposants pour une racine carrée est une alternative à l'importation de la sqrtfonction dans le mathmodule.

Longueur 13:

1 if x else 0

Ceci est un exemple d'opérateur ternaire if de Python. Cela a été ajouté dans Python 2.5 pour décourager les codeurs de l'implémenter manuellement avec des opérations booléennes. Ici, 1retourne si xévalue True, sinon 0est retourné.

Longueur 12:

s=input(">")

Cela imprimera >le texte d'invite et permettra à l'utilisateur de saisir une valeur. Python 2 interprète quelle que soit la valeur entrée. Toute chaîne nécessite des guillemets. Python 3 a changé cela, de sorte que l'entrée entrée n'est pas automatiquement interprétée. Pour entrer une entrée sans l’interpréter en Python 2, utilisez raw_input(). En Python 2, input()est équivalent à eval(raw_input()).

Longueur 11:

eval("2e3")

2e3est la notation scientifique du flotteur 2 x 10³. La evalfonction interprète et évalue toute chaîne en tant qu'expression. Dans ce cas, cela a le même résultat que d'utiliser le littéral 2e3ou float("2e3"). Ça revient 2000.0.

Longueur 10:

range(013)

Cette fonction renvoie une liste d'entiers allant 0de la valeur octale 013, qui est 11(exclusive), ce qui signifie que la liste le sera [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]. La fonction prend jusqu'à trois paramètres similaires à la slicefonction que nous avons examinés plus tôt: range(start, stop[, step]). La différence est que, avec un seul paramètre, le paramètre représente la valeur d'arrêt.

Notez que Python 3.x n’a pas d’équivalent. C'est rangesimilaire, mais c'est en fait le même que celui de Python 2 xrange, renvoyant un objet générateur au lieu d'une liste.

Longueur 9:

a,b = b,a

Affectation multiple. C’est une fonction simple mais élégante, qui vous permet d’attribuer plusieurs valeurs en même temps. Dans l'extrait fourni, il échange aetb . Qu'en est-il de l'ordre d'évaluation, demandez-vous? Toutes les expressions situées à droite de l'opérateur d'affectation sont évaluées avant toute affectation. Cela bat beaucoup de langues qui nécessitent une affectation intermédiaire à une variable temporaire.

Longueur 8:

#comment

Tu sais ce que c'est ... Attends, tu sais pas? Vous savez, ces choses qui vous permettent de taper du texte arbitraire pour décrire une ligne de code, le rendant plus facile à comprendre? Non? Ah d'accord...

Longueur 7:

l[::-1]

Encore une fois en supposant l s’agit d’une liste, la liste sera renvoyée dans l’ordre inverse. Le troisième argument indique la taille du pas. Comme les trois arguments peuvent être des valeurs négatives, une taille de pas négative signifie une itération dans l'ordre inverse. Les premier et deuxième arguments vides montrent que nous parcourons toute la liste.

Nous arrivons là où nous pouvons commencer à utiliser des constructions plus intéressantes!

Longueur 6:

l[-6:]

Cela s'appelle une opération slice . Si lest une liste, cela retournera une nouvelle liste contenant les six derniers éléments de lla liste. -6représente l'index de départ (6 à partir de la fin), et les deux points signifient continuer jusqu'à l'index de fin qui le suit (ce que nous avons laissé en blanc, donc à la fin.) Si notre liste contenait les nombres de 1 à 10, cela reviendrait [5, 6, 7, 8, 9, 10].

Longueur 5:

1<x<5

L'une des fonctionnalités impressionnantes de Python vous permet de chaîner des opérateurs de comparaison. Dans de nombreuses autres langues, cela serait tapé comme 1 < x && x < 5. Cela devient encore meilleur quand on considère plusieurs comparaisons: 1 < x < y < 5c'est parfaitement valide!

Longueur 4:

0256

Un entier avec un zéro non significatif est une valeur octale littérale. C'est aussi un bon truc pour dissimuler le code. Ceci retourne la valeur décimale 174. Dans Python 3.x, la valeur octale serait écrite sous la forme 0o256.

Longueur 3:

`3`

Le fait d’entourer une expression dans une règle est la même chose que d’utiliser repr(), qui renvoie la représentation sous forme de chaîne d’un objet. La fonction tente de renvoyer la chaîne de telle manière que, lorsqu'elle est transmise en tant qu'argument à la evalfonction, elle renvoie l'objet d'origine. Ce n'est pas la même chose que d'utiliser str(), même si les résultats sont parfois les mêmes. Pour cette entrée, '3'est retourné dans les deux cas. C'est un de mes favoris pour le golf de code!

Fonctionne en Python 2 seulement!

Longueur 2:

[]

Une liste vide

Longueur 1:

_

Le caractère de soulignement est un nom de variable jetable très utilisé. Si vous utilisez un interpréteur Python (interpréteur interactif), il conserve le résultat de la dernière instruction exécutée (et le renverrait à nouveau). De plus, selon ce fil , il est également utilisé pour la recherche de traduction dans i18n.

Factoid : Python est un langage similaire à Java et C. Il a été construit avec une philosophie de conception spécifique (tirée de " PEP 20 - Le zen de Python ":

• Beau vaut mieux que moche
• Explicite vaut mieux qu'implicite
• Simple c'est mieux que complexe
• Complexe vaut mieux que compliqué
• La lisibilité compte

À cause de cela, bien que les points-virgules soient autorisés en tant que délimiteur d'instruction, ils sont généralement omis en faveur de l'utilisation de plusieurs lignes pour des raisons de lisibilité. En outre, l'indentation de la ligne est très importante!

JavaScript

Cela va du plus récent au plus ancien. Lien pour moi-même: [ modifier ]

Longueur 51 extrait:

console.log(require('fs').readFileSync(__filename))

Une quine Node.JS cette fois, bien qu’elle échoue à toutes les exigences de "quine stricte", à cause de la lecture de son propre code source.

Longueur 50 extrait:

a=new XMLHttpRequest;a.open('GET','file');a.send()

Finalement! Une demande AJAX (utilisant Vanilla.JS ). Nous initialisons, ouvrons et envoyons la demande, mais je n’ai plus assez de place pour ajouter des gestionnaires et faire quoi que ce soit avec le résultat.

Longueur 49 extrait:

msg=new SpeechSynthesisUtterance('Hello World!');

Préparez une voix "Hello World!". Ce sera un peu plus de travail pour le parler réellement. Nous pouvons également régler le volume, la hauteur, la vitesse et l'accent. Voir API de synthèse vocale sur HTML5Rocks . Pas encore supporté par Firefox, certainement pas IE .

Longueur 48 extrait:

function repeat(){setTimeout(repeat,48)}repeat()

Simuler setIntervalen récursivement setTimeouting.

Longueur 47 extrait:

module.exports=function MyModule(a) {this.a=a};

NodeJS encore, mais le principe est le même partout dans JS. C'est une fonction constructeur très basique, qui crée un objet avec une propriété ( a). Setting module.exportsexporte la fonction pour l’utiliser en la require()remplaçant.

Longueur 46 extrait:

canvas.getContext('2d').fillRect(46,46,46,46);

Cela nécessite un <canvas id="canvas"></canvas>élément. Il tire parti du fait que les éléments avec ID sont renseignés en tant que variables globales, de sorte que l'élément est accessible à canvaspartir de JS. Ensuite, nous le remplissons avec un carré de 46x46 à x = 46, y = 46.

Longueur 45 extrait:

JSON.parse(require('fs').readFileSync('jsn'))

Retour au nœud. Ici, nous analysons un fichier JSON nommé à jsnpartir du répertoire actuel.

Longueur 44 extrait:

(a=document.createElement('a')).href="/url";

Construire sur # 39. Maintenant, nous créons un élément et assignons un attribut. Ce n'est toujours pas dans le DOM cependant.

Longueur 43 extrait:

sq=[1,2,3,4,5].map(function(n){return n*n})

Crée un tableau des 5 premiers carrés, en utilisant map().

Longueur 42 extrait:

six="1+5",nine="8+1";eval(six+' * '+nine);

Cela fonctionne sur le même principe que cela , mais JS manque #defineet finit par être plus laid. Cela rend, bien sûr, la réponse à la vie, à l'univers et à tout .

Longueur 41 extrait:

c=function(){var i;return function(){}}()

Le début d'une fermeture. cest maintenant une fonction (la interne) avec accès à la variable interne i, mais ne fait rien.

Longueur 40 extrait:

$('p').click(function(){$(this).hide()})

Nous supprimons totalement ces paragraphes et utilisons jQuery.

Longueur 39 extrait:

script=document.createElement('script')

C'est le début de l'ajout d'un nouveau script externe. Créez un <script>élément vide et conservez une référence à celui-ci.

Longueur 38 extrait:

document.getElementsByClassName('abc')

Retrouvez tous les .abcéléments du document. Bien sûr, avec jQuery, c'est seulement $('.abc')...

Longueur 37 extrait:

b=JSON.parse(JSON.stringify(a={3:7}))

Crée deux objets identiques, mais découplés a, et b. Si tu ferais

a={a:1};
b=a;
b.a=3;

vous vous retrouveriez avec a=={a:3}, parce que aet bpointez sur le même objet. Nous utilisons JSON pour les découpler.

Longueur 36 extrait:

(function f(){return "("+f+")()"})()

Une quine . Il imprime son propre code source.

Longueur 35 extrait:

document.body.style.display="none";

Voir n ° 32. Celui-ci ne fait que masquer le document, sans écraser le contenu.

Longueur 34 extrait:

Object.prototype.toString.call(34)

L'appel Object.prototype.toStringest un bon moyen de connaître le type d'un objet. Tout en 34..toString()est "34", l'extrait est [object Number].

Longueur 33 extrait: (le crédit pour celui-ci va à un utilisateur anonyme )

+0%-0.&(v\u0061r=~void[{}<<!(0)])

Vous pensez que ce n'est pas valide JavaScript? Mieux vaut essayer ... (utiliser Chrome);)

Longueur 32 extrait:

document.body.innerHTML="hacked"

Halp! Hazxxors! Onze !! 11!

Longueur 31 extrait:

a=[];for(i=0;i<31;i++)a.push(i)

Sans blague, j'ai attendu si longtemps pour pouvoir utiliser une forboucle! Celui-ci crée un tableau de 0-30.

Longueur 30 extrait:

new Date().getDay()==1?"S":"E"

Première utilisation de l'opérateur ternaire. Je ne pouvais pas faire plus que cela dans 30 caractères, donc nous savons seulement si nous sommes aujourd'hui dimanche ou quelque chose d'autre. : P

Longueur 29 extrait:

Object.keys(window).push('i')

Object.keys(window)obtiendra un tableau des variables globales (propriétés de window). .push()ajoutera un élément à ce tableau. Vous pensez que c'est l'équivalent de window.i=undefined? Nan!

Longueur 28 extrait:

setTimeout("a=confirm()",28)

Attendre 28 millisecondes n’est pas très utile, sauf pour créer un nouveau thread.

Longueur 27 extrait:

document.querySelector('a')

Dommage que les noms DOM soient si longs. Je ne pouvais obtenir qu'un seul lien ici.

Longueur 26 extrait:

JSON.stringify({twenty:6})

Voir n ° 16. Nous obtenons maintenant le JSON réel - une chaîne.

Longueur 25 extrait:

new Badge("Good Answer");

En supposant Badge()qu’une fonction constructeur prenne une dispute ... un badge Bonne réponse vient d’être créé!

Longueur 24 extrait:

do {alert(24)} while(!1)

En fait, je n'en utilise pas do..whilebeaucoup, mais certains le font. Si c'était une whileboucle ordinaire , cela n'alerte rien, parce que c'est toujours faux. do..whilefonctionnera toujours au moins une fois, nous allons donc pouvoir en voir 24.

Longueur 23 extrait:

window.parent==self.top

Ceux-ci se réfèrent tous au même objet, généralement appelé window. Si vous appelez une fonction normalement, il y a aussi this. C'est 5 façons d'accéder à l'objet global!

Longueur 22 extrait:

for(i in self)alert(i)

Alerte toutes les variables globales. Il se trouve que self==window. (Voir l'extrait suivant.)

Longueur 21 extrait:

"2"+1==21 && 2+1=="3"

Oh regarde, ce sont encore les règles de casting de JS. Cette déclaration est vraie, d'ailleurs.

Longueur 20 extrait:

Math.random()<.5?0:1

Choisissez un nombre aléatoire de 0 à 1 et arrondissez à l'aide de l'opérateur ternaire. Bien que ce soit plus facile à utiliser Math.round...

Longueur 19 extrait:

[1,2,3].map(i=>i*i)

Celui-ci est nouveau. Comme, vraiment nouveau. Il utilise les fonctions fléchées ES6 pour calculer les carrés de 1, 2 et 3. Actuellement, il ne semble être supporté que par Firefox.

Longueur 18 extrait:

location.href="/";

Comme le n ° 15, mais cette fois, il se rend sur la page d'accueil du PPCG, pas sur SE.

Longueur 17 extrait:

(function(){})()

C'est l'extrait de 14, mais mieux! Maintenant c'est un IIFE.

Longueur 16 extrait:

obj={not:'json'}

Cela explique l'une de mes bévues. Ceci est un objet , pas JSON ! JSON est un format d'échange de données basé sur des objets JavaScript, mais prenant un format plus strict.

Longueur 15 extrait:

open('//s.tk/')

Imagine ça. Ouvrez la page d'accueil SE en utilisant la redirection http://s.tk/ .

Longueur 14 extrait:

function f(){}

W00t! Les fonctions! Dommage qu'il n'y ait pas de place pour faire quoi que ce soit.

Longueur 13 extrait:

Math.random()

Générez un nombre aléatoire de 0 à 1. Vous souhaitez définir vos propres limites? Mauvais chance. (Pas vraiment, c'est facile.)

Longueur 12 extrait:

new Date<=12

Cette affirmation n’a jamais été vraie dans JS. JS n'a été créé qu'en 1995 (voir factoid), longtemps après le 01/01/1970 00: 00: 00.012.

Longueur 11 extrait:

Math.PI*121

L'aire d'un cercle de rayon 11.

Longueur 10 extrait: