Skip to content

L'imprimante entière polyvalente

Si vous rencontrez quelque chose qui vous fait douter, vous pouvez le laisser dans la section des commentaires et nous essaierons de vous aider le plus rapidement possible.

Solution :

15 langues, 6866 65 octets / 15^3 = 0.019...

Rétine, Starry, Prélude, ETA, Axo, Labyrinthe, Hexagonie, Foo, Brian & Chuck, Gol><>, maléfique, Espace blanc, Fission, <> et GolfScript.

Après une réécriture massive, j'ai réussi à intégrer quatre langues supplémentaires. Le code contient les quelques tabulations pour les espaces blancs. Comme Stack Exchange les convertit en espaces, je les ai représentées par . t en dessous :

#I5aeeNTH{?      tt + +3;[email protected]"8"ea9
15}7'`[email protected]<"31"LSOe.t
 teaww`

Je pense que j'ai fini d'ajouter des langues (bien que l'ajout d'une seule pourrait économiser quelques octets dans ce que j'ai déjà). Je me demande cependant si c'est jouable... 65 octets pour 15 langues est un sacré saut par rapport à 32 octets pour 11 langues, et j'ai maintenant au moins un caractère inutile là-dedans pour faire fonctionner Foo....

Impressions Retina 1

Essayez-le en ligne.

Par chance, la première ligne est une regex valide. Cependant, cette regex ne correspond évidemment pas à l'entrée vide, donc la première étape (composée des deux premières lignes) ne fait rien.

La troisième ligne est seule, elle est donc traitée comme une étape Match qui, par défaut, compte le nombre de correspondances. Cependant, l'étape ` est un séparateur qui indique à Retina que la partie qui le précède est une chaîne de configuration (il se trouve qu'elle ne connaît aucune des options données ici) et que la partie qui le suit est la regex. Donc la regex est vide et Retina trouve exactement une correspondance.

Impressions étoilées 2

Essayez-le en ligne.

Starry ignore tout sauf les espaces et +*,'`.. Chaque commande est un de ces caractères en conjonction avec les espaces depuis le dernier de ces caractères. Supprimons donc tout le code superflu :

       + +'`. `

Sept espaces suivis de + pousse un 2. Un espace suivi d'un + le duplique. ' est un saut conditionnel. Il fait sauter le sommet de la pile, ce qui est véridique (positif), donc il saute à l'étiquette correspondante (où les étiquettes sont indiquées par ` et "correspondant" signifie "avec le même nombre d'espaces de tête"), qui est la première étiquette de la pile. `. . sans espace devant, puis imprime le haut de la pile comme un nombre.

Prelude imprime 3

Essayez-le en ligne.

Cela suppose l'interpréteur Python qui utilise une sortie numérique. Enlevons tous les no-ops :

# 5        ?         + +3    8   9
15 7  -- !   31

La première voix fait un tas de choses, mais rien de tout cela n'a d'importance, car il n'y a pas de... ! pour imprimer un quelconque résultat. La seconde voix pousse un 1puis un 5puis un 7. On prend la différence des deux derniers pour obtenir -2et on la soustrait de la valeur de 1 pour obtenir 3. ! l'imprime. La troisième voix n'a que des no-ops.

ETA imprime 4

Essayez-le en ligne.

ETA ignore tout sauf les caractères ETAOINSH (dans tous les cas). Donc le code tel que vu par ETA est :

IaeeNTHneaSOeea

I essaie de lire l'entrée mais ne peut pas, donc il pousse -1. a pousse le numéro de la ligne actuelle plus 1, ce qui est 2. e est divmod qui les remplace par 0 et 1 (ou -1je ne le sais pas vraiment, mais cela n'a pas d'importance). Le prochain e remplace les deux par 0.

Maintenant la partie intéressante. NTHne est un nombre littéral en base 7. N et e sont juste les délimiteurs, et les trois chiffres sont THN. C'est-à-dire 54 (où T est le chiffre 1, H est 0 et n est 5). a pousse 2 une fois de plus. S le soustrait, ce qui donne 52 et O l'édite comme un caractère (4). Maintenant e essaie à nouveau divmod, mais la pile contient deux zéros, donc le programme se termine avec une erreur (mais ne pollue pas STDOUT pendant ce temps).

Axo imprime 5

Essayez-le en ligne.

Ce langage a été à peu près seul responsable de la réécriture. Je ne pouvais pas avoir le } sur la première ligne parce que cela aurait bloqué pour l'entrée dans Axo (voir l'historique des révisions pour savoir de quoi je parle). Pour Axo, seule cette partie du code est pertinente :

#I5aeeNTH{

Heureusement, Axo a aussi des 0implicites au bas de sa pile, car # fait sauter le sommet de la pile (pour vérifier si l'instruction suivante doit être sautée ou non). Les lettres sont toutes des no-ops. Ensuite, 5 pousse un 5, { l'imprime, termine le programme. Assez simple, vraiment.

Labyrinth imprime 6

Essayez-le en ligne.

Je tronque un peu le code, car la moitié droite n'est jamais atteinte, et j'utilise aussi t à la place de tafin que les colonnes s'alignent correctement :

#I5aeeNTH{
15}7'`[email protected]
 teaww`

Maintenant que les lettres, espaces et tabulations sont des murs dans Labyrinth, le code accessible ressemble en fait à ceci :

# 5      {
15}7'`[email protected]
      `

Le pointeur d'instruction suivra automatiquement ce chemin. # pousse la profondeur de la pile principale (0) et 15 le transforme en un 15. } le déplace sur la pile auxiliaire, et nous ne l'utiliserons plus. Cela rend commodément le sommet de la pile nul, de sorte que l'IP ne tourne pas à gauche sur le 5. 7 .5. 7transforme le zéro en un 7, ' est un no-op. Le site ` est une négation unaire, donc on obtient -7. Maintenant - soustrait le -7 de l'implicite 0 en dessous, ce qui en fait 7. Cette fois, l'IP se tourne vers la droite, vers le `.`qui est une négation unaire, donc nous obtenons 7 à nouveau. L'IP se retrouve dans une impasse et fait demi-tour. Le site - fait la même chose que précédemment, donc on obtient 7 une fois de plus. Comme le haut de la pile est maintenant positif, l'IP tourne à droite. Il y a un autre - qui donne -7 à nouveau. Puis ~ est un NON binaire, ce qui donne 6 et ! l'imprime. C'est juste le bon moment pour le faire, car maintenant la pile est à nouveau vide, de sorte que l'IP ne tournera pas à gauche sur la ligne { mais continue tout droit dans la zone @ ce qui termine le programme.

Hexagonie imprime 7

Essayez-le en ligne.

Le code déplié ressemble à ceci :

     # I 5 a e
    e N T H { 
   ? + + 3 ; n @
  " 8 " e a 9 1 5
 } 7 ' - - ~ ! @ <
  " 3 1 " L S O e
   . e a w w . .
    . . . . . .
     . . . . .

Normalement, ce serait un programme Hexagone terrifiant, mais les caractères réellement utilisés ne sont pas trop nombreux. En fait, ils sont à peu près les mêmes que ceux utilisés par Labyrinth et je pense que la façon dont je fais la différence entre... 5 et 6 est assez sympa 🙂

La rangée du haut peut être ignorée. # devrait normalement passer à un autre IP, mais le bord de mémoire actuel est 0donc il ne le fait pas. Les lettres fixent juste une valeur de mémoire fixe, mais nous n'allons pas l'utiliser. Après la fin de la première rangée, le flux de contrôle continue dans la rangée du milieu (à partir de la lettre }en allant vers la droite). Le site } se déplace vers un autre bord de mémoire. 7 place ce bord sur 7. ' retourne à l'endroit d'où nous venons. - soustrait l'arête de mémoire que nous venons de régler sur 7 d'un bord de mémoire non utilisé (0), nous obtenons donc -7. Le prochain - fait à nouveau la même chose, donc c'est un no-op. Jusqu'ici, assez similaire à Labyrinth (à part la disposition de la mémoire). Mais maintenant ~ n'est pas un bitwise NOT mais une négation unaire dans Hexagonie. Cela donne donc 7 au lieu de 6. [email protected]comme dans Labyrinth, imprime la valeur et termine le programme.

Foo imprime 8

Essayez-le en ligne.

Comme nous le savons tous depuis The Programming Language Quiz imprimer des choses est assez trivial dans Foo, même si la plupart du code est un fouillis aléatoire de caractères. Aucun des caractères n'affecte la sortie, sauf le "8" qui imprime 8. Il y a le caractère "31" plus tard, mais Foo se termine par une erreur à la fin de la première ligne. Je ne suis pas exactement sûr de la raison pour laquelle cela arrive, mais il faut que 3 (ou n'importe quel autre chiffre) sur la ligne du haut, qui n'est utilisé nulle part ailleurs.

Impressions de Brian et Chuck 9

Essayez-le en ligne.

Refaisons ce truc où nous supprimons la troisième ligne (elle n'est jamais analysée) et remplaçons tous les caractères non pertinents (c'est-à-dire les no-ops, ou les cellules qui ne sont pas lues) par des espaces :

         { ?         + +         9
  }   --   <        .

Pour rappel, chaque ligne est un Brainfuck-like dont la bande est le code source de l'autre programme. Le flux de contrôle commence sur la première ligne (appelée Brian).

Le site { déplace la tête de bande tout à fait à gauche (là où elle est déjà), et le ? . ? transmet le flux de contrôle à Chuck (la deuxième ligne). Là, } déplace la tête de bande vers la droite jusqu'à ce qu'il trouve une cellule zéro. Cela ne se produit pas avant la fin du programme, donc la tête de bande se retrouve une cellule après la ligne 9. - .9. -décrémente cette cellule, mais ce n'est pas pertinent. < déplace la tête de bande sur la cellule 9 et . l'imprime. Chuck n'a plus de programme et se termine.

Gol><> imprime 10

Testé ici.

# est un miroir, donc l'IP saute immédiatement à la fin de la première ligne (et va à gauche). Le site 9 peut être ignoré. a pousse 10, e pousse 14, "8" pousse le code de caractère de 8, @ fait tourner les trois éléments supérieurs de la pile (en tirant vers le haut l'élément 10), de telle sorte que n imprime le 10 et ; termine le programme.

Merci à Sp3000 d'avoir suggéré d'utiliser @ au lieu de ! (ce qui a permis d'économiser un octet).

le mal imprime 11

Merci à Sp3000 de m'avoir envoyé des listes de commandes par force brute pour générer des nombres à un chiffre.

Essayez-le en ligne.

Le mal ignore tout sauf les lettres minuscules, donc le code ressemble à ceci :

aeeneaeeaww

Aussi, n affecte un état dont nous ne nous soucions pas, alors ignorons-le aussi. Maintenant a incrémente le registre (qui commence à 0), et e est l'opération magique de "tissage" du mal qui permute les bits d'une manière particulière. aeeeaeea donne la valeur 49 qui est le code de caractère de 1. ww l'imprime deux fois.

L'espace blanc imprime 12

Essayez-le en ligne.

Ok, nous savons que Whitespace ne lit que les espaces, les tabulations et les sauts de ligne, alors écrivons le code tel que vu par Whitespace avec STL:

SSSSSSTTSSLTLST

Cela fait deux commandes :

SSSSSSTTSSL
TLST

La première pousse le nombre 12. Plus précisément, SS démarre un littéral numérique. Le suivant S est le bit de signe (positif). Ensuite, tout jusqu'au L est une représentation binaire du nombre. Il y a une tonne de zéros de tête, dont nous avons besoin pour Starry, mais ils n'affectent pas le nombre. Ensuite le TTSSest 12 en binaire. Fait amusant : si j'ajoutais une 16ème langue, je pourrais économiser un octet ici, car Starry pourrait utiliser les quatre S dans la représentation binaire de 16. Je doute que je le fasse cependant...

Le TLST imprime juste le haut de la pile comme un nombre. (TL marque la commande comme une commande E/S, et ST imprime des nombres).

Fission imprime 13

Essayez-le en ligne.

Fission ne voit que cette partie du code :

           <"31"L

L commence le flux de contrôle avec un atome partant à gauche. " bascule le mode d'impression, de sorte que 31 imprime seulement 13. Ensuite, l'atome est capturé dans le coin de l'élément <, ce qui met fin au programme.

<> imprime 14

Testé ici.

Distinguer entre ><> et Gol><> n'est pas aussi facile que je le pensais, car Gol><> fait presque toujours la même chose que ><> pour les commandes qui existent dans les deux, et les commandes qui n'existent que dans Gol><> font planter ><>. Cependant, @ tourne dans l'autre sens dans ><>, de telle sorte qu'elle pousse vers le bas la commande 7 au lieu de tirer vers le haut le 10et ensuite le 14 est imprimé au lieu du 10.

GolfScript imprime 15

Essayez-le en ligne.

Celui-ci est le plus simple : # commente la première ligne. Puis 15 se pousse et } est un "super commentaire", qui ignore tout le reste du programme. Donc le 15 est imprimé à la fin du programme.

30 langues, 248 octets, 248/30^3 = 0.009185

#|#?15g,@           kkmNmSaIeoe99+{#/-;[email protected]
#[[email protected]>.>.eeaww#[email protected]*"12" L
#{  
###
#`{
25
print(4^2 +7)/2

"""
Jo is here.
$'main'MoO OOM
 7
>Jo, 30
>X Jo
f::=~27
::=]##}#(prin 29)
print (7/6*24)###;alert 2#-[>+<-----]>-.|#(write(if(= 1/5 .2)26 3))"""

Editer : Beatnik supprimé puisque le test de primalité dans Beatnik pourrait ne pas être possible.

Le code comporte des tabulations (qui sont gâchées par Stack Exchange) et un saut de ligne de fin, alors voici le code suivant xxd:

00000000: 237c 233f 3135 672c 4020 2020 0920 2020  #|#?15g,@   .   
00000010: 206b 6b6d 4e6d 5361 4965 6f65 3939 2b7b   kkmNmSaIeoe99+{
00000020: 5c23 2f2d 3b6e 4030 6561 0a23 5b39 2140  #/-;[email protected]#[[email protected]
00000030: 3e2e 3e2e 6565 6177 7723 2d31 402a 2231  >.>.eeaww#[email protected]*"1
00000040: 3222 094c 0a23 7b20 090a 2323 230a 2360  2".L.#{ ..###.#`
00000050: 7b0a 3235 0a70 7269 6e74 2834 5e32 202b  {.25.print(4^2 +
00000060: 3729 2f32 0a0a 0a22 2222 0a4a 6f20 6973  7)/2...""".Jo is
00000070: 2068 6572 652e 0a24 276d 6169 6e27 4d6f   here..$'main'Mo
00000080: 4f20 4f4f 4d0a 2037 0a3e 4a6f 2c20 3330  O OOM. 7.>Jo, 30
00000090: 0a3e 5820 4a6f 0a66 3a3a 3d7e 3237 0a3a  .>X Jo.f::=~27.:
000000a0: 3a3d 5d23 237d 2328 7072 696e 2032 3929  :=]##}#(prin 29)
000000b0: 0a70 7269 6e74 2028 372f 362a 3234 2923  .print (7/6*24)#
000000c0: 2323 3b61 6c65 7274 2032 232d 5b3e 2b3c  ##;alert 2#-[>+<
000000d0: 2d2d 2d2d 2d5d 3e2d 2e7c 2328 7772 6974  -----]>-.|#(writ
000000e0: 6528 6966 283d 2031 2f35 202e 3229 3236  e(if(= 1/5 .2)26
000000f0: 2033 2929 2222 220a                       3))""".

Alternativement, vous pouvez copier et coller le code à partir de ce lien "Essayez-le en ligne !".

C'est assez mal foutu, mais je voulais jouer sur l'idée qu'une fois que vous avez suffisamment de langues, le nombre d'octets n'a plus autant d'importance. Cela dit, il y a certains langages que je pourrais encore facilement ajouter (par exemple Objeck) mais qui sont actuellement trop longs pour être utiles. Je suis à court de bonnes langues cependant, donc je pourrais m'arrêter là pour le moment.

Exécuter tous les programmes avec /dev/null (c'est-à-dire entrée vide, STDERR surpressé).

L'explication est assez longue, alors voici un résumé :

No.  Lang.              Non-esolang?     2D esolang?      BF/BF-deriv?
--------------------------------------------------------------------------
1    COW                                                       ✓
2    CoffeeScript            ✓
3    Common Lisp             ✓
4    Retina
5    Befunge-93                               ✓
6    Python 2                ✓
7    Rail                                     ✓
8    ETA
9    Prelude
10   Gol><>                                   ✓
11   evil
12   Foo                                                       ✓
13   Ruby                    ✓
14   ><>                                      ✓
15   Brian & Chuck                                             ✓
16   Whitespace
17   3var
18   Axo                                      ✓
19   Labyrinth                                ✓
20   Starry
21   Fission                                  ✓
22   Brainfuck                                                 ✓
23   Julia                   ✓
24   Lily                    ✓
25   GolfScript
26   Chicken Scheme          ✓
27   Thue
28   Perl 6                  ✓
29   Picolisp                ✓
30   TRANSCRIPT

1. COW

COW est un dérivé de Brainfuck avec des commandes supplémentaires, dont l'une est la sortie numérique. Tout ce qui est invalide est ignoré, donc le programme exécuté est simplement...

MoO OOM

qui incrémente la cellule à 1 puis l'imprime comme un nombre.

2. CoffeeScript (comprend l'interpréteur)

CoffeeScript voit :

# comments
###
multiline comment
###;alert 2# comment

qui alerte simplement 2.

(Oui, ce serait probablement mieux si un autre langage prenait cet emplacement, mais je suis trop paresseux pour remanier à ce stade :P).

3. Common Lisp | ideone

Common Lisp (clisp) voit :

#|
multiline comment
|#(write(if(= 1/5 .2)26 3))"""

1/5 est un rationnel et n'est pas égal à 0.2, donc 3 est imprimé. La procédure """ est une erreur de syntaxe.

Notez que print semble sortir un newline précédent et un espace arrière en Common Lisp. Cependant, heureusement, write fonctionne à la fois dans Common Lisp et Chicken Scheme.

4. Retina | Essayez-le en ligne !

Introduction de restrictions: Chaque deuxième ligne à partir de la première doit être une regex valide.

Chaque paire de lignes forme une étape de remplacement, remplaçant les instances de correspondances de la regex de la première ligne par la deuxième ligne. Au milieu, nous avons la paire

"""

qui remplace la chaîne vide initiale par """. La dernière ligne vide, qui ne fait partie d'aucune paire, est traitée comme une étape de correspondance, comptant le nombre de correspondances de la regex. Il y a quatre instances de la chaîne vide dans """à savoir 1"2"3"4.

5. Befunge-93 | Interprète

Befunge est un langage 2D, et les instructions correspondantes sont les suivantes

# # 15g,@

dans la première ligne, et les instructions 5 dans la 25 ligne. # saute l'instruction suivante, 15g reçoit le caractère à la position (1, 5) dans le code (l'instruction 5 dans le 25 ligne), , édite le caractère et @ s'arrête.

6. Python 2 | idéone

Python voit :

# comments
25
print(4^2 +7)/2

"""
multiline string
"""

(4^2+7)/2 = (xor(4,2)+7)/2 = (6+7)/2 = 13/2 = 6, qui obtient printed.

7. Rail | Essayez-le en ligne !

Rail est un langage 2D, et l'exécution commence à partir de l'... $ de la fonction principale, en direction du sud-est. Ainsi, la partie pertinente du code est

$'main'
 7
  o
   J

avec le o et J provenant des lignes utilisées par TRANSCRIPT. Après la sortie de 7, le train rencontre une ligne non reconnue. J non reconnue, ce qui fait planter le programme.

8. ETA | Essayez-le en ligne !

Restrictions introduites : Les caractères précédant le programme ETA ne doivent pas être en... etaoinsh.

L'ETA ne reconnaît que les lettres etaoinsh et leurs versions en majuscules, ce qui signifie que le code commence par

NSaIeoe

n...e pousse un nombre en base 7 basé sur ce qui se trouve dans les délimiteurs, qui pour SaI est 624ou 312 en décimal. o sort ensuite comme un caractère, apparemment après modulo 256, ce qui donne le caractère 8 (point de code 56). e essaie ensuite de diviser avec une pile vide, ce qui échoue.

9. Prélude | Essayez en ligne !

Restrictions introduites : Pas plus d'un () dans une colonne, () correspondant à la lecture d'une colonne à la fois, pas de boucles infinies causées par ().

Cela nécessite que l'interpréteur Python dispose de la fonction NUMERIC_OUTPUT = True réglé.

Prelude est un langage où chaque ligne est exécutée séparément. Beaucoup de caractères sont exécutés, mais la partie importante est le caractère

9!

sur la deuxième ligne, qui sort 9. () dans Prelude dénotent une boucle, mais grâce à la proéminence de #(qui sortent de la pile), les sommets des piles sont toujours à 0 au moment où une boucle est atteinte, donc aucune d'entre elles n'est exécutée. Les restrictions du code source de Prelude concernant () ont introduit quelques espaces superflus.

10. Gol><> | Interprète

Cette partie (et ><>) fonctionne comme la réponse de Martin. Le code pertinent est

#                                      ;[email protected]

Gol><> est un langage 2D et # reflète le PI, le faisant voyager vers la gauche. Il s'enroule autour, pousse 10, 14 et 0 sur la pile. @ puis fait tourner la pile, en amenant 10 au sommet, n le sort et ; arrête le programme.

11. mal | Essayez-le en ligne !

Cette partie est également similaire à la réponse de Martin.

evil ignore tout sauf les lettres minuscules. En ignorant quelques caractères de plus, la partie pertinente est

aeeeaeeaww

a incrémente la variable A, e est la fonction de tissage du mal qui mélange les bits de la variable Aet w sort A. Par conséquent, nous produisons 1 deux fois, ce qui donne 11.

Mais qu'en est-il du reste des instructions, et en particulier de l'instruction w sur la dernière ligne ? Disons que, parfois, il est plus facile d'embrouiller le code et de prier pour qu'il fonctionne toujours, ce qui, ici, a été le cas...

12. Foo | Essayez-le en ligne !

Foo sort tout ce qui se trouve entre les guillemets doubles, donc la partie pertinente est l'...

"12"

sur la deuxième ligne. Cependant, puisque nous avons besoin de guillemets doubles plus tard, nous utilisons une méthode similaire à la réponse de Martin pour faire en sorte que Foo fasse une erreur, à savoir ce qui précède. #[email protected]. Il n'est pas clair pourquoi cela fonctionne dans un langage qui poursuit ses soldats face aux erreurs de pile vide et de division par zéro, mais je suis content que cela fonctionne.

13. Ruby | ideone

Comme Python, Ruby voit :

# comments
25
print(4^2 +7)/2

"""
multiline string
"""

Cependant, il convient de noter que la chaîne multiligne est en fait trois chaînes distinctes ("", "...", "") concaténées ensemble. La ligne d'impression produit (4^2+7) = xor(4,2)+7 = 6+7 = 13avant de se tromper en essayant de diviser nil par 2.

14. ><> | Essayez-le en ligne !

Cette partie est la même que la partie Gol><>, sauf que @ fait remonter le 14 en haut à la place, ce qui est édité.

15. Brian & Chuck | Essayez-le en ligne !

Brian & Chuck est un dérivé de BF avec deux bandes, où le pointeur d'instruction d'une bande est le pointeur de mémoire de l'autre bande. En l'absence de ```, les deux premières lignes du code source sont utilisées pour initialiser les bandes.

Les caractères pertinents dans les deux premières lignes sont :

   ?15
#     >.>.

Le site ?de la bande de Brian transmet le contrôle à Chuck dans la cellule pointée (le caractère #) est non nulle. Chuck exécute alors >.>.en sortant les deux caractères après le point d'interrogation.

16. Espace blanc | Interprète

Utilisation de STL pour l'espace, la tabulation et le saut de ligne respectivement, le début du programme est :

SSSTSSSSL
TL
STL
L
L

La première ligne pousse 16 (+10000 base 2), la ligne précédente TLST l'imprime comme un nombre. Les trois lignes suivantes arrêtent le programme.

Notez, cependant, que ce programme est spécifique à l'interpréteur. Le reste des erreurs de syntaxe du code dans la plupart des interpréteurs, il faut donc un interpréteur plus indulgent, comme celui lié ci-dessus.

17. 3var | Essayez-le en ligne !

De la première ligne, une foule d'instructions sont exécutées, mais les plus importantes sont les suivantes

kkmmao#/

En raison de la restriction de l'ETA, nous utilisons k pour décrémenter la variable B plutôt que a pour l'incrémenter. kk décrémente B à -2 et mm élève B deux fois au carré à 16, qui est incrémenté à 17 avec a. Ceci est ensuite sorti avec o.

# est ensuite utilisé pour remettre B à 0, et / provoque l'erreur du programme par division par 0.

18. Axo | Essayez en ligne !

Restrictions introduites : Pas d'instructions avant le programme Axo qui modifient la direction de l'IP.

Une fois de plus, une série d'instructions sont exécutées dans la première ligne, mais les plus importantes sont les suivantes

# # 15 ,@            9 9  + {   

Axo est un langage 2D comme Befunge, et # est de la même façon un pont qui saute l'instruction suivante, mais seulement si le haut de la pile est à zéro. 15, poussent sur la pile, mais la pile est vidée avec @. 99+ puis pousse 18, { sort et s'arrête.

19. Labyrinthe | Essayez-le en ligne !

Labyrinth est un autre langage 2D, et les instructions exécutées sont .

#|#
 [[email protected]

# pousse la longueur de la pile, qui est de 0 la première fois. | est un OU bit à bit, ne changeant rien puisque la pile n'a que des 0 à ce stade, et la deuxième fois. # pousse maintenant le 1 à cause du zéro solitaire. On tourne à droite à cause du 1, 9 convertit ce 1 en 1*10+9 = 19, ! l'imprime et @ s'arrête.

Ce programme s'appuie sur le fait que [ n'est pas actuellement une instruction reconnue, et est donc traitée comme un mur.

20. Starry | Essayez-le en ligne !

Restrictions introduites : Tous +doivent être précédés d'au moins un espace

Si nous éliminons les caractères non reconnus, la partie pertinente du code est la suivante

,       +.. +

, est l'entrée, mais puisque nous pipeons de /dev/null il n'y en a pas, ce qui pousse 0 sur la pile. A + avec n >= 5 précédant les espaces, pousse n-5donc l'instruction suivante pousse 2. .. sort ensuite ces deux chiffres dans l'ordre inverse.

Ensuite, nous avons un + avec un seul espace précédent, qui se duplique. Cependant, la pile est vide, donc nous nous trompons.

21. Fission | Essayez-le en ligne !

La seule partie pertinente pour Fission est

*"12"L

L donne naissance à un atome se déplaçant vers la gauche, "21" imprime 21 et * s'arrête.

22. Brainfuck | Essayez-le en ligne !

Introduction de restrictions : Non . avant le premier [

Cela nécessite un interpréteur qui donne 0 sur EOF et a des cellules de 8 bits. Le code correspondant est

,+-[>.>.-+.>,>]-[>+<-----]>-..

Le code initial - initial est destiné à décaler le +et le premier [...] n'est pas exécutée puisque la cellule est 0. La cellule suivante -[>+<-----]>- suivante attribue à la cellule le code de caractère de 2et .. l'édite deux fois.

23. Julia | Essayez en ligne !

Julia voit :

# comments
25
print(4^2 +7)/2

Ce qui est imprimé est 4^2+7 = pow(4,2)+7 = 16+7 = 23et le programme se trompe en essayant de diviser nothing par 2. Notez que Julia ne semble pas se soucier du fait que le reste du code causerait de toute façon une erreur de syntaxe.

24. Lily | Interprète

Lily voit :

# comment
#[
multiline comment
]## comment
print (7/6*24)# comment

7/6*24 = 1*24 = 24 est imprimé.

25. GolfScript | Essayez-le en ligne !

GolfScript voit :

# comments
25
print(

GolfScript est basé sur la pile, donc 25 est poussé sur la pile, puis poppé et imprimé avec. print. ( puis tente de décrémenter la chaîne vide implicite sur la pile, ce qui échoue et fait sortir le programme par erreur.

26. Chicken Scheme | ideone

Chicken Scheme a la même #| ... |# syntaxe de commentaire multiligne que le Common Lisp. Cependant, dans

(write(if(= 1/5 .2)26 3))

1/5 est un flottant qui est égale à 0.2donc 26 est affiché à la place.

27. Thue | Essayez-le en ligne !

Thue est un langage basé sur la réécriture de chaînes de caractères. La première partie pertinente est

f::=~27
::=

qui définit une substitution f -> 27 puis dénote la fin des substitutions avec ::=. Le solitaire f dans if est alors remplacé par 27qui est édité.

28. Perl 6 | idéone

Perl 6 possède une nouvelle syntaxe de commentaire, à savoir . #`(some bracket) qui est un commentaire multiligne jusqu'à la parenthèse correspondante. Ainsi, Perl 6 voit :

# comments
#`{
multiline comment
}# comment
print (7/6*24)# comment

qui imprime 7/6*24 = 28.

29. Picolisp | ideone

Picolisp voit :

# comment
#{
multiline comment
}#(prin 29)

qui imprime 29. La ligne suivante provoque alors une erreur de syntaxe.

30. TRANSCRIPT | Essayez-le en ligne !

TRANSCRIPT est un esolang thématique modelé sur les aventures textuelles. Les lignes non reconnues sont ignorées (ce qui vous permet d'ajouter un texte supplémentaire d'histoire/de saveur parmi les instructions de code réelles), donc les lignes pertinentes sont :

Jo is here.
>Jo, 30
>X Jo

La première ligne déclare une variable de type chaîne de caractères Joen utilisant un nom à deux lettres puisque les noms à une lettre semblent échouer. La deuxième ligne fixe cette chaîne à "30"qui est affichée par X ("examine") dans la troisième ligne.

Python 1.x, 2.x et 3.x, 32 octets / 3^3 = 1,1851...

import sys
print(sys.version[0])

Imprime le premier numéro de la version, qui est le suivant. 1 dans Python 1.x, 2 dans Python 2.x et 3 dans Python 3.x.

D'ici à ce que nous obtenions Python 9.x, mon score sera un glorieux 0.04389!

:~) !

Section des critiques et des évaluations

Rappelez-vous quelque chose, que vous pouvez opter pour l'option de clarification.



Utilisez notre moteur de recherche

Ricerca
Generic filters

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.