30 lingue, 248 byte, 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))"""
Modifica: Beatnik rimosso poiché i test di primalità in Beatnik potrebbero non essere possibili.
Il codice contiene delle schede (che vengono alterate da Stack Exchange) e una nuova riga finale, quindi ecco il 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))""".
In alternativa, puoi copiare e incollare il codice da questo "Provalo online!" link .
Questo è piuttosto maledetto, ma volevo sminuire l'idea che, una volta che hai abbastanza lingue, il conteggio dei byte non ha più importanza. Detto questo, ci sono alcune lingue che potrei ancora facilmente aggiungere (ad esempio Objeck) ma al momento sono troppo lunghe per essere utili. Sono a corto di buone lingue, quindi per ora potrei fermarmi qui.
Esegui tutti i programmi con </dev/null 2>/dev/null(ovvero input vuoto, STDERR compresso).
La spiegazione è piuttosto lunga, quindi ecco un riassunto esecutivo:
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 è un derivato di Brainfuck con comandi aggiuntivi, uno dei quali è un output numerico. Tutto ciò che non è valido viene ignorato, quindi il programma eseguito è semplicemente
MoO OOM
che aumenta la cella a 1, quindi la stampa come un numero.
CoffeeScript vede:
# comments
###
multiline comment
###;alert 2# comment
che avvisa semplicemente 2.
(Sì, probabilmente sarebbe meglio se un'altra lingua prendesse questo slot, ma sono troppo pigro per rimescolare a questo punto: P)
Common Lisp (clisp) vede:
#|
multiline comment
|#(write(if(= 1/5 .2)26 3))"""
1/5è un valore razionale e non uguale a 0.2, quindi viene stampato 3. Il procedimento """è un errore di sintassi.
Si noti che printsembra generare una nuova riga precedente e spazio finale in Common Lisp. Tuttavia, per fortuna, writefunziona sia in Common Lisp che in Chicken Scheme.
Restrizioni introdotte : ogni seconda riga a partire dalla prima deve essere una regex valida.
Ogni coppia di righe forma una fase di sostituzione, sostituendo le istanze di corrispondenze della regex della prima riga con la seconda riga. Nel mezzo, abbiamo la coppia
"""
che sostituisce la stringa vuota iniziale con """. L'ultima riga vuota, che non fa parte di nessuna coppia, viene trattata come una fase della partita, contando il numero di partite della regex. Ci sono quattro istanze di stringa vuota in """, vale a dire 1"2"3"4.
Befunge è un linguaggio 2D e le relative istruzioni sono
# # 15g,@
nella prima riga e 5nella 25riga. #salta l'istruzione successiva, 15gottiene il carattere in posizione (1, 5)nel codice (il 5nella 25riga), ,emette il carattere e si @ferma.
Python vede:
# comments
25
print(4^2 +7)/2
"""
multiline string
"""
(4^2+7)/2 = (xor(4,2)+7)/2 = (6+7)/2 = 13/2 = 6, che viene printed.
Rail è un linguaggio 2D e l'esecuzione inizia dalla $funzione principale, in direzione sud-est. Pertanto, la parte pertinente del codice è
$'main'
7
o
J
con oe Jproveniente dalle linee utilizzate da TRANSCRIPT. Dopo aver emesso 7, il treno riceve Jun'istruzione non riconosciuta , che arresta in modo anomalo il programma.
Restrizioni introdotte: i caratteri prima del programma ETA non dovrebbero essere presenti etaoinsh.
ETA riconosce solo le lettere etaoinshe le loro versioni maiuscole, il che significa che il codice inizia con
NSaIeoe
n...espinge un numero di base 7 in base a ciò che è all'interno dei delimitatori, che per SaIè 624, o 312 in decimale. oquindi emette come carattere, apparentemente dopo il modulo 256, dando il carattere 8(codice punto 56). equindi tenta di dividere con uno stack vuoto, che non riesce.
Restrizioni introdotte: non più di una di ()ogni colonna, ()abbinata alla lettura di una colonna alla volta, nessun loop infinito causato da ().
Ciò richiede che l'interprete Python sia NUMERIC_OUTPUT = Trueimpostato.
Preludio è una lingua in cui ogni riga viene eseguita separatamente. Molti caratteri vengono eseguiti, ma la parte importante è il
9!
sulla seconda riga, che produce 9. ()in Prelude denotano un loop, ma grazie alla prominenza di #s (che salta dallo stack), le cime degli stack sono sempre 0 quando viene colpito un loop, quindi nessuno di loro sono gestiti. Le restrizioni del codice sorgente di Prelude in merito hanno ()introdotto alcuni spazi estranei.
Questa parte (e> <>) funziona come la risposta di Martin . Il codice rilevante è
# ;n@0ea
Gol> <> è un linguaggio 2D e #riflette l'IP, facendolo viaggiare verso sinistra. Si avvolge, spinge 10, 14 e 0 nello stack. @quindi ruota lo stack, portando 10 in alto, lo nemette e ;ferma il programma.
Questa parte è anche simile alla risposta di Martin.
il male ignora tutto tranne le lettere minuscole. Ignorando qualche altro personaggio, la parte rilevante è
aeeeaeeaww
dove aincrementa la variabile A, eè la funzione di intreccio del male che mescola i bit di A, ed wemette A. Quindi abbiamo prodotto 1due volte, dando 11.
Ma per quanto riguarda il resto delle istruzioni, e in particolare quello wdell'ultima riga? Diciamo solo che a volte è più semplice pasticciare con il codice e pregare che funzioni ancora in tutto ciò che, qui, in qualche modo ha fatto ...
Foo emette qualcosa tra virgolette doppie, quindi la parte rilevante è il
"12"
sulla seconda riga. Tuttavia, poiché in seguito abbiamo bisogno di virgolette doppie, utilizziamo un metodo simile alla risposta di Martin per eliminare l'errore Foo, vale a dire il precedente #-1@. Non è chiaro il motivo per cui funziona in una lingua su cui i soldati affrontano lo stack vuoto e la divisione per zero errori, ma sono contento che lo faccia.
Come Python, Ruby vede:
# comments
25
print(4^2 +7)/2
"""
multiline string
"""
Tuttavia, vale la pena notare che la stringa multilinea è in realtà tre stringhe separate ( "", "...", "") concatenato insieme. La linea di stampa (4^2+7) = xor(4,2)+7 = 6+7 = 13viene emessa, prima di sbagliare cercando di dividere nilper 2.
Questa parte è uguale alla parte Gol> <>, tranne per il fatto che @porta 14 in cima, che viene emesso.
Brian & Chuck è un derivato BF con due nastri, in cui il puntatore alle istruzioni di un nastro è il puntatore di memoria dell'altro nastro. In assenza di ```, le prime due righe del codice sorgente vengono utilizzate per inizializzare i nastri.
I caratteri rilevanti nelle prime due righe sono:
?15
# >.>.
Il ?nastro di Brian passa il controllo a Chuck nella cella a cui viene indicato (il #) è diverso da zero. Chuck quindi esegue >.>., emettendo i due caratteri dopo il punto interrogativo.
Utilizzando rispettivamente STLper spazio, tabulazione e avanzamento riga, l'avvio del programma è:
SSSTSSSSL
TL
STL
L
L
La prima riga spinge 16 ( +10000base 2), la precedente la TLSTstampa come numero. Le tre righe successive interrompono il programma.
Si noti, tuttavia, che questo programma è specifico dell'interprete. Il resto degli errori di sintassi del codice nella maggior parte degli interpreti, quindi è necessario un interprete più indulgente, come quello sopra indicato.
Della prima riga, viene eseguita una serie di istruzioni, ma quelle pertinenti lo sono
kkmmao#/
A causa della restrizione dell'ETA, usiamo kper ridurre la variabile B piuttosto che aper aumentarla. kkdiminuisce da B a -2 e mmpiazza B due volte a 16, che viene incrementato a 17 con a. Questo viene quindi emesso con o.
#viene quindi utilizzato per reimpostare B su 0 e /causa l'errore del programma tramite divisione per 0.
Restrizioni introdotte: nessuna istruzione prima del programma Axo che modifica la direzione dell'IP
Ancora una volta, una serie di istruzioni viene eseguita nella prima riga, ma quelle pertinenti lo sono
# # 15 ,@ 9 9 + { \
Axo è un linguaggio 2D come Befunge ed #è allo stesso modo un bridge che salta l'istruzione successiva, ma solo se la parte superiore dello stack è zero. 15,spingere verso lo stack, ma lo stack viene svuotato con @. 99+quindi spinge 18, {esce e si \ferma.
Labyrinth è un altro linguaggio 2D e le istruzioni eseguite sono
#|#
[9!@
#spinge la lunghezza della pila, che è 0 la prima volta. |è OR bit a bit, non cambia nulla poiché lo stack ha solo 0s a questo punto, e il secondo #ora spinge 1 a causa dello zero solitario. Giriamo a destra a causa dell'1, lo 9converte in 1 1*10+9 = 19, lo !stampa e si @ferma.
Questo programma si basa sul fatto che [attualmente non è un'istruzione riconosciuta, e quindi viene trattato come un muro.
Restrizioni introdotte: tutti gli +s devono avere almeno uno spazio precedente
Se eliminiamo i caratteri non riconosciuti, la parte rilevante del codice è
, +.. +
,viene immesso, ma dal momento che eseguiamo il pipe da /dev/nulllì non c'è nessuno, spingendo 0 nello stack. A +con n >= 5spazi precedenti spinge n-5, quindi l'istruzione successiva spinge 2. ..quindi emette queste due cifre in ordine inverso.
Successivamente abbiamo un +con un unico spazio precedente, che duplica. Tuttavia, lo stack è vuoto, quindi eliminiamo l'errore.
L'unica parte rilevante per Fission è
*"12"L
Lgenera un atomo che si muove verso sinistra, "21"stampa 21 e si *ferma.
Restrizioni introdotte: No .prima del primo[
Ciò richiede un interprete che dia 0 su EOF e abbia celle a 8 bit. Il codice rilevante è
,+-[>.>.-+.>,>]-[>+<-----]>-..
L'iniziale -serve per compensare il +, e il primo [...]non viene eseguito poiché la cella è 0. Quanto segue -[>+<-----]>-imposta la cella sul codice char di 2, e la ..emette due volte.
Julia vede:
# comments
25
print(4^2 +7)/2
Ciò che è stampato è 4^2+7 = pow(4,2)+7 = 16+7 = 23 , e il programma si spegne cercando di dividere nothingper 2. Nota che a Julia non sembra importare il fatto che il resto del codice provocherebbe comunque un errore di sintassi.
Lily vede:
# comment
#[
multiline comment
]## comment
print (7/6*24)# comment
7/6*24 = 1*24 = 24 è stampato.
GolfScript vede:
# comments
25
print(
GolfScript è basato sullo stack, quindi 25 viene inserito nello stack, quindi visualizzato e stampato con print.(quindi tenta di decrementare la stringa vuota implicita nello stack, che non riesce ed elimina il programma.
Chicken Scheme ha la stessa #| ... |#sintassi dei commenti multilinea di Common Lisp. Tuttavia, in
(write(if(= 1/5 .2)26 3))
1/5è un galleggiante che è uguale a 0.2, quindi 26 viene emesso invece.
Quindi è un linguaggio basato sulla riscrittura delle stringhe. La prima parte rilevante è
f::=~27
::=
che definisce una sostituzione f -> 27quindi indica la fine delle sostituzioni con ::=. Il lone fin ifviene quindi sostituito con 27, che viene emesso.
Perl 6 ha una nuova sintassi di commento, vale a dire #`(some bracket)che è un commento multilinea fino alla parentesi corrispondente. Pertanto, Perl 6 vede:
# comments
#`{
multiline comment
}# comment
print (7/6*24)# comment
che stampa 7/6*24 = 28.
Picolisp vede:
# comment
#{
multiline comment
}#(prin 29)
che stampa 29. La riga successiva provoca quindi un errore di sintassi.
TRANSCRIPT è un esolang tematico modellato su avventure testuali. Le righe non riconosciute vengono ignorate (il che consente di aggiungere un ulteriore testo storia / sapore tra le istruzioni del codice effettivo), quindi le righe pertinenti sono:
Jo is here.
>Jo, 30
>X Jo
La prima riga dichiara una variabile stringa Jo, usando un nome di due lettere poiché i nomi di una lettera sembrano fallire. La seconda riga imposta questa stringa su "30", che viene emessa da X("esaminare") nella terza riga.
2.7.1a2.7.n. (In realtà, sweerpotato fa proprio questo con le versioni principali.)