30 langues, 248 octets, 248/30 ^ 3 = 0.009185
#|#?15g,@ kkmNmSaIeoe99+{\#/-;n@0ea
#[9!@>.>.eeaww#-1@*"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))"""
Edit: Beatnik enlevé car les tests de primalité dans Beatnik pourraient ne pas être possibles.
Le code contient des onglets (qui sont mutilés par Stack Exchange) et une fin de ligne, alors voici le 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 \#/-;n@0ea.#[9!@
00000030: 3e2e 3e2e 6565 6177 7723 2d31 402a 2231 >.>.eeaww#-1@*"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 de cette "Essayez-le en ligne!" lien .
C'est assez mal joué, mais je voulais jouer sur l'idée qu'une fois que vous avez assez de langues, compter le nombre d'octets n'a plus autant d'importance. Cela dit, il y a certaines langues que je pourrais encore facilement ajouter (par exemple, Objeck), mais qui sont actuellement trop longues pour être utiles. Je manque de bonnes langues, alors je vais peut-être m'arrêter ici pour l'instant.
Exécutez tous les programmes avec </dev/null 2>/dev/null(c.-à-d. 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
COW est un dérivé de Brainfuck avec des commandes supplémentaires, dont l’une est une sortie numérique. Tout élément invalide est ignoré, le programme exécuté est donc simplement
MoO OOM
qui incrémente la cellule à 1 puis l’imprime sous la forme d’un nombre.
CoffeeScript voit:
# comments
###
multiline comment
###;alert 2# comment
qui alerte simplement 2.
(Oui, ce serait probablement mieux si une autre langue prenait cette place, mais je suis trop paresseux pour remanier à ce stade: P)
Common Lisp (clisp) voit:
#|
multiline comment
|#(write(if(= 1/5 .2)26 3))"""
1/5est un rationnel et pas égal à 0.2, donc 3 est imprimé. La procédure """est une erreur de syntaxe.
Notez que cela printsemble générer une nouvelle ligne et un dernier espace dans Common Lisp. Cependant, heureusement, writefonctionne à la fois dans le programme Common Lisp et dans le programme de poulet.
Restrictions introduites : chaque seconde ligne commençant par la première doit être une expression rationnelle valide.
Chaque paire de lignes forme une étape de remplacement, remplaçant les occurrences des correspondances de la regex de la première ligne par la deuxième. 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, en comptant le nombre de correspondances de l'expression régulière. Il y a quatre occurrences de chaîne vide dans """, à savoir 1"2"3"4.
Befunge est un langage 2D et les instructions appropriées sont
# # 15g,@
dans la première ligne, et 5dans la 25ligne. #saute l'instruction suivante, 15gobtient le caractère à la position (1, 5)dans le code (le 5dans la 25ligne), ,sort le caractère et @s'arrête.
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.
Le rail est un langage 2D et l'exécution commence à partir $de la fonction principale, en direction du sud-est. Ainsi, la partie de code pertinente est
$'main'
7
o
J
avec le oet Jvenant des lignes utilisées par TRANSCRIPT. Après la sortie 7, le train frappe une Jinstruction non reconnue , ce qui bloque le programme.
Restrictions introduites: les caractères antérieurs au programme ETA ne doivent pas être insérés etaoinsh.
ETA ne reconnaît que les lettres etaoinshet leurs versions majuscules, ce qui signifie que le code commence par
NSaIeoe
n...epousse un nombre de base 7 basé sur le contenu des délimiteurs, qui SaIest 624, ou 312 en décimal. opuis sort en tant que caractère, apparemment après le modulo 256, donnant le caractère 8(point de code 56). etente ensuite de se diviser avec une pile vide, ce qui échoue.
Restrictions introduites: pas plus d'une ()dans une colonne, ()correspondance d'une lecture de colonne à la fois, pas de boucles infinies causées par ().
Cela nécessite que l'interpréteur Python se soit NUMERIC_OUTPUT = Truedéfini.
Prelude est un langage dans lequel chaque ligne est exécutée séparément. Beaucoup de caractères sont exécutés, mais la partie importante est la
9!
sur la deuxième ligne, qui sort 9. ()dans Prelude, désigne une boucle, mais grâce à la proéminence de #s (qui sort de la pile), les sommets des piles sont toujours à 0 au moment où une boucle est touchée, donc aucun sont courus. Les restrictions de code source de Prelude concernant l’ ()introduction de certains espaces superflus.
Cette partie (et> <>) fonctionne comme la réponse de Martin . Le code pertinent est
# ;n@0ea
Gol> <> est un langage 2D et #reflète l’IP, le faisant se déplacer vers la gauche. Il encercle, poussez 10, 14 et 0 à la pile. @fait ensuite tourner la pile en ramenant 10 au sommet, la nsort et ;arrête le programme.
Cette partie est également similaire à la réponse de Martin.
le mal ignore tout sauf les minuscules. Ignorant quelques caractères supplémentaires, la partie pertinente est
aeeeaeeaww
où aincrémente la variable A, eest la fonction de tissage du mal qui mélange les bits de A, et les wsorties A. Par conséquent, nous produisons 1deux fois, donnant 11.
Mais qu'en est-il du reste des instructions, et en particulier wde la dernière ligne? Disons simplement qu'il est parfois plus facile de manipuler le code et de prier pour qu'il fonctionne toujours dans tout ce qui, ici, a tout ...
Foo affiche tout ce qui se trouve entre guillemets, la partie pertinente est donc la
"12"
sur la deuxième ligne. Cependant, comme nous avons besoin de guillemets plus tard, nous utilisons une méthode similaire à celle de Martin pour éliminer l’erreur Foo, à savoir la méthode précédente #-1@. On ne sait pas pourquoi cela fonctionne dans une langue dans laquelle les soldats sont confrontés à une pile vide et à des erreurs de division par zéro, mais je suis heureux que ce soit le cas.
Comme Python, Ruby voit:
# comments
25
print(4^2 +7)/2
"""
multiline string
"""
Cependant, il est intéressant de noter que la chaîne multiligne est en fait trois chaînes distinctes ( "", "...", "") concaténés. La ligne d’impression est imprimée (4^2+7) = xor(4,2)+7 = 6+7 = 13avant d’essayer de diviser nilpar 2.
Cette partie est la même que la partie Gol> <>, sauf que @le 14 est placé en haut, ce qui produit une sortie.
Brian & Chuck est un dérivé de BF avec deux bandes, le pointeur d’instruction d’une bande étant le pointeur de mémoire de l’autre. 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
# >.>.
La ?bande de Brian passe le contrôle à Chuck dans la cellule désignée (la #) est non nulle. Le mandrin s'exécute ensuite >.>.et affiche les deux caractères après le point d'interrogation.
En utilisant respectivement STLespace, tabulation et saut de ligne, le programme commence:
SSSTSSSSL
TL
STL
L
L
La première ligne pousse 16 ( +10000base 2), la précédente l' TLSTimprime sous forme de nombre. Les trois prochaines nouvelles lignes interrompent le programme.
Notez cependant que ce programme est spécifique à l’interprète. Le reste des erreurs de syntaxe de code dans la plupart des interprètes, un interprète plus indulgent est donc nécessaire, comme celui ci-dessus.
De la première ligne, une série d'instructions sont exécutées, mais les plus pertinentes sont
kkmmao#/
En raison des restrictions imposées par ETA, nous utilisons khabituellement pour décrémenter la variable B plutôt que apour l’incrémenter. kkdécrémente B en -2 et le mmcarré B deux fois en 16, qui est incrémenté de 17 avec a. Ceci est ensuite sorti avec o.
#est ensuite utilisé pour réinitialiser B à 0 et /provoque la sortie d'erreur du programme via une division par 0.
Restrictions introduites: aucune instruction avant le programme Axo ne modifie le sens de l'IP
Encore une fois, une série d'instructions sont exécutées dans la première ligne, mais les plus pertinentes sont
# # 15 ,@ 9 9 + { \
Axo est un langage 2D similaire à Befunge. Il #s'agit également d'un pont qui saute l'instruction suivante, mais uniquement si le haut de la pile est égal à zéro. 15,pousser à la pile, mais la pile est vidée avec @. 99+puis pousse 18, {sorties et \s'arrête.
Labyrinth est un autre langage 2D, et les instructions exécutées sont
#|#
[9!@
#pousse la longueur de la pile, qui est 0 la première fois. |est au niveau du bit OU, ne changeant rien car la pile ne contient que des 0, et la seconde #pousse maintenant 1 en raison du zéro isolé. On tourne à droite à cause du 1, 9convertit ce 1 en 1*10+9 = 19, l’ !imprime et @s’arrête.
Ce programme repose sur le fait que l’ [instruction n’est pas reconnue à l’heure actuelle et qu’il est donc traité comme un mur.
Restrictions introduites: Tous les +s doivent avoir au moins un espace précédent
Si nous supprimons les caractères non reconnus, la partie pertinente du code est
, +.. +
,est entré, mais puisque nous dirigeons à partir de /dev/nulllà, il n’y en a pas, poussant 0 dans la pile. A +avec n >= 5les espaces précédents pousse n-5, alors l'instruction suivante pousse 2. ..puis sort ces deux chiffres dans l'ordre inverse.
Ensuite, nous avons un +avec un seul espace précédent, qui est dupliqué. Cependant, la pile est vide, nous avons donc une erreur.
La seule partie pertinente pour la fission est
*"12"L
Lengendre un atome qui se déplace vers la gauche, "21"imprime 21 et *s'arrête.
Restrictions introduites: non .avant la première[
Cela nécessite un interpréteur qui donne 0 sur EOF et a des cellules de 8 bits. Le code pertinent est
,+-[>.>.-+.>,>]-[>+<-----]>-..
L'inital -consiste à décaler le +, et le premier [...]n'est pas exécuté car la cellule est à 0. Ce qui suit -[>+<-----]>-définit la cellule sur le code de caractère de 2et le ..sort deux fois.
Julia voit:
# comments
25
print(4^2 +7)/2
Ce qui est imprimé, c’est 4^2+7 = pow(4,2)+7 = 16+7 = 23, et le programme fait erreur, en essayant de diviser nothingpar 2. Notez que Julia ne semble pas s’inquiéter du fait que le reste du code causerait de toute façon une erreur de syntaxe.
Lily voit:
# comment
#[
multiline comment
]## comment
print (7/6*24)# comment
7/6*24 = 1*24 = 24 est imprimé.
GolfScript voit:
# comments
25
print(
GolfScript est basé sur une pile. 25 est donc placé dans la pile, puis sauté et imprimé print. (tente ensuite de décrémenter la chaîne vide implicite sur la pile, ce qui échoue et entraîne une erreur dans le programme.
Chicken Scheme a la même #| ... |#syntaxe de commentaire multiligne que Common Lisp. Cependant, dans
(write(if(= 1/5 .2)26 3))
1/5est un flotteur qui est égal à 0.2, donc 26 est plutôt émis.
Thue est un langage basé sur la réécriture de chaînes. La première partie pertinente est
f::=~27
::=
qui définit une substitution f -> 27indique alors la fin des substitutions avec ::=. Le seul fdans ifest ensuite remplacé par 27, qui est sorti.
Perl 6 a une nouvelle syntaxe de commentaire, à savoir #`(some bracket)un commentaire multiligne allant jusqu'au crochet correspondant. Ainsi, Perl 6 voit:
# comments
#`{
multiline comment
}# comment
print (7/6*24)# comment
qui imprime 7/6*24 = 28.
Picolisp voit:
# comment
#{
multiline comment
}#(prin 29)
qui imprime 29. La ligne suivante provoque ensuite une erreur de syntaxe.
TRANSCRIPT est un esolang thématique inspiré d’aventures textuelles. Les lignes non reconnues sont ignorées (ce qui vous permet d'ajouter un texte d'histoire ou de saveur supplémentaire parmi les instructions de code réelles). Les lignes pertinentes sont donc:
Jo is here.
>Jo, 30
>X Jo
La première ligne déclare une variable chaîne Jo, en utilisant un nom à deux lettres, car les noms à une lettre semblent échouer. La deuxième ligne définit cette chaîne sur "30", qui est sortie par X("examine") dans la troisième ligne.
2.7.1à2.7.n. (En fait, sweerpotato ne fait que cela avec les versions majeures.)