30 idiomas, 248 bytes, 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 removido, pois o teste de primalidade no Beatnik pode não ser possível.
O código possui guias (que são alteradas pelo Stack Exchange) e uma nova linha à direita, então aqui está o 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))""".
Como alternativa, você pode copiar e colar o código em "Experimente online!" link .
Isso é muito ruim, mas eu queria jogar fora a idéia de que, uma vez que você tenha idiomas suficientes, a contagem de bytes não importará mais. Dito isto, existem alguns idiomas que eu ainda poderia adicionar facilmente (por exemplo, Objeck), mas atualmente são muito longos para serem úteis. Estou ficando sem boas línguas, então posso parar por enquanto.
Execute todos os programas com </dev/null 2>/dev/null(ou seja, entrada vazia, STDERR suprimido).
A explicação é bastante longa, então aqui está um resumo executivo:
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 é um derivado do Brainfuck com comandos adicionais, um dos quais é saída numérica. Qualquer coisa inválida é ignorada; portanto, o programa executado é meramente
MoO OOM
que incrementa a célula para 1 e a imprime como um número.
O CoffeeScript vê:
# comments
###
multiline comment
###;alert 2# comment
que simplesmente alerta 2.
(Sim, provavelmente seria melhor se outro idioma ocupasse esse espaço, mas estou com preguiça de reorganizar neste momento: P)
Lisp comum (clisp) vê:
#|
multiline comment
|#(write(if(= 1/5 .2)26 3))"""
1/5é racional e não é igual a 0.2, portanto 3 é impresso. O processo """é um erro de sintaxe.
Observe que printparece gerar uma nova linha anterior e um espaço à direita no Common Lisp. No entanto, felizmente, writefunciona tanto no Common Lisp quanto no Chicken Scheme.
Restrições introduzidas : Cada segunda linha que começa na primeira precisa ser um regex válido.
Cada par de linhas forma um estágio de substituição, substituindo instâncias de correspondências do regex da primeira linha pela segunda linha. No meio, temos o par
"" "
que substitui a cadeia vazia inicial por """. A linha final vazia, que não faz parte de nenhum par, é tratada como um estágio de correspondência, contando o número de correspondências da regex. Existem quatro instâncias de cadeia vazia """, a saber 1"2"3"4.
O Befunge é uma linguagem 2D e as instruções relevantes são
# # 15g,@
na primeira linha e 5na na 25linha. #pula a próxima instrução, 15gcoloca o char na posição (1, 5)do código ( 5na 25linha), ,gera o char e @pára.
Python vê:
# comments
25
print(4^2 +7)/2
"""
multiline string
"""
(4^2+7)/2 = (xor(4,2)+7)/2 = (6+7)/2 = 13/2 = 6, que é printed.
O trilho é uma linguagem 2D e a execução começa $na função principal, na direção sudeste. Assim, a parte relevante do código é
$'main'
7
o
J
com oe Jprovenientes de linhas usadas pelo TRANSCRIPT. Após a saída 7, o trem atinge uma Jinstrução não reconhecida , que trava o programa.
Restrições introduzidas: Os caracteres antes do programa ETA não devem estar incluídos etaoinsh.
O ETA reconhece apenas as letras etaoinshe suas versões maiúsculas, o que significa que o código começa com
NSaIeoe
n...eenvia um número 7 base com base no que está dentro dos delimitadores, ou SaIseja 624, 312 em decimal. oentão sai como char, aparentemente após o módulo 256, fornecendo o char 8(ponto de código 56). eentão tenta dividir com uma pilha vazia, que falha.
Restrições introduzidas: não mais do que um ()em qualquer coluna, ()correspondendo a leitura de uma coluna por vez, nenhum loop infinito causado por ().
Isso requer que o interpretador Python tenha NUMERIC_OUTPUT = Truedefinido.
Prelúdio é um idioma em que cada linha é executada separadamente. Muitos caracteres são executados, mas a parte importante é a
9!
na segunda linha, que emite 9. ()no Prelude, denota um loop, mas graças à proeminência de #s (que sai da pilha), as partes superiores das pilhas são sempre 0 no momento em que um loop é atingido, portanto, nenhuma delas São executados. Porém, as restrições de código-fonte do Prelude relacionadas a ()alguns espaços estranhos foram introduzidas.
Esta parte (e> <>) funciona como a resposta de Martin . O código relevante é
# ;n@0ea
Gol> <> é uma linguagem 2D e #reflete o IP, fazendo com que ele viaje para a esquerda. Ele envolve, empurra 10, 14 e 0 para a pilha. @depois gira a pilha, trazendo 10 para o topo, nsai e ;interrompe o programa.
Esta parte também é semelhante à resposta de Martin.
o mal ignora tudo, exceto letras minúsculas. Ignorando mais alguns caracteres, a parte relevante é
aeeeaeeaww
onde aincrementa a variável A, eé a função de tecer do mal que embaralha os bits Ae as wsaídas A. Por isso, produzimos 1duas vezes, dando 11.
Mas e o restante das instruções, e especialmente wna última linha? Digamos que, às vezes, é mais fácil mexer no código e rezar para que ele ainda funcione em tudo o que, aqui, de alguma forma funcionou ...
Foo produz qualquer coisa entre aspas duplas, então a parte relevante é a
"12"
na segunda linha. No entanto, como precisamos de aspas duplas posteriormente, usamos um método semelhante à resposta de Martin para cometer um erro de Foo, ou seja, o anterior #-1@. Não está claro por que isso funciona em uma linguagem na qual os soldados enfrentam a pilha e a divisão vazias por zero erros, mas estou feliz que sim.
Como Python, Ruby vê:
# comments
25
print(4^2 +7)/2
"""
multiline string
"""
No entanto, é importante notar que a cadeia de múltiplas linhas é realmente três cordas separadas ( "", "...", "") concatenados. A linha de impressão é impressa (4^2+7) = xor(4,2)+7 = 6+7 = 13antes de ocorrer um erro ao tentar dividir nilpor 2.
Essa parte é a mesma que a parte Gol> <>, exceto que @os 14 chegam ao topo, que é gerado.
Brian & Chuck é um derivado de BF com duas fitas, onde o ponteiro de instruções de uma fita é o ponteiro de memória da outra. Na ausência de ```, as duas primeiras linhas do código fonte são usadas para inicializar as fitas.
Os caracteres relevantes nas duas primeiras linhas são:
?15
# >.>.
A ?fita da Brian passa o controle para Chuck na célula que está sendo apontada (o #) é diferente de zero. Chuck então executa >.>., produzindo os dois caracteres após o ponto de interrogação.
Usando STLespaço, tabulação e avanço de linha, respectivamente, o início do programa é:
SSSTSSSSL
TL
STL
L
L
A primeira linha empurra 16 ( +10000base 2), a anterior a TLSTimprime como um número. As próximas três novas linhas interrompem o programa.
Observe, no entanto, que este programa é específico para intérpretes. O restante dos erros de sintaxe do código na maioria dos intérpretes, portanto, é necessário um intérprete mais brando, como o vinculado acima.
Na primeira linha, várias instruções são executadas, mas as relevantes são
kkmmao#/
Devido à restrição do ETA, usamos kpara diminuir a variável B em vez de aincrementá-la. kkdecrementa B para -2 e B para mmquadrados duas vezes para 16, o que é incrementado para 17 com a. Isso é gerado com o.
#é então usado para redefinir B para 0 e /causa erro no programa via divisão por 0.
Restrições introduzidas: Nenhuma instrução antes do programa Axo que altere a direção do IP
Mais uma vez, várias instruções são executadas na primeira linha, mas as relevantes são
# # 15 ,@ 9 9 + { \
Axo é uma linguagem 2D como o Befunge, e #é similarmente uma ponte que pula a próxima instrução, mas apenas se o topo da pilha for zero. 15,empurre para a pilha, mas a pilha será esvaziada @. 99+depois empurra 18, {sai e \pára.
Labirinto é outra linguagem 2D, e as instruções executadas são
#|#
[9!@
#empurra o comprimento da pilha, que é 0 na primeira vez. |é bit a bit OR, não alterando nada, já que a pilha só tem 0s nesse momento, e a segunda #agora empurra 1 devido ao zero solitário. Viramos à direita devido ao 1, 9converte esse 1 em 1*10+9 = 19, !imprime e @pára.
Este programa baseia-se no fato de que [atualmente não é uma instrução reconhecida e, portanto, é tratado como um muro.
Restrições introduzidas: Todos os +s devem ter pelo menos um espaço anterior
Se removermos caracteres não reconhecidos, a parte relevante do código será
, +.. +
,é entrada, mas, como canalizamos de /dev/nulllá, não há, empurrando 0 para a pilha. A +com n >= 5espaços anteriores pressiona n-5, então a próxima instrução pressiona 2. em ..seguida, gera esses dois dígitos na ordem inversa.
Em seguida, temos um +com um único espaço anterior, que é duplicado. No entanto, a pilha está vazia, então nós cometemos erros.
A única parte relevante para a fissão é
*"12"L
Lgera um átomo se movendo para a esquerda, "21"imprime 21 e *pára.
Restrições introduzidas: não .antes da primeira[
Isso requer um intérprete que dê 0 no EOF e tenha células de 8 bits. O código relevante é
,+-[>.>.-+.>,>]-[>+<-----]>-..
O inicial -é compensar o +, e o primeiro [...]não é executado, pois a célula é 0. O seguinte -[>+<-----]>-define a célula para o código de char de 2e a ..gera duas vezes.
Julia vê:
# comments
25
print(4^2 +7)/2
O que é impresso é 4^2+7 = pow(4,2)+7 = 16+7 = 23e o programa falha ao tentar dividir nothingpor 2. Observe que Julia não parece se importar com o fato de que o restante do código causaria um erro de sintaxe de qualquer maneira.
Lily vê:
# comment
#[
multiline comment
]## comment
print (7/6*24)# comment
7/6*24 = 1*24 = 24 é impresso.
GolfScript vê:
# comments
25
print(
O GolfScript é baseado em pilha, então 25 é empurrado para a pilha e, em seguida, exibido e impresso print. (Em seguida, tenta diminuir a seqüência vazia implícita na pilha, que falha e gera erros no programa.
O esquema de galinhas possui a mesma #| ... |#sintaxe de comentário multilinha que o Common Lisp. No entanto, em
(write(if(= 1/5 .2)26 3))
1/5é um float que é igual a 0.2, então 26 é gerado.
Thue é um idioma baseado na reescrita de strings. A primeira parte relevante é
f::=~27
::=
que define uma substituição e f -> 27depois denota o fim das substituições por ::=. O solitário fem ifé então substituída com 27, o qual é emitido.
O Perl 6 tem uma nova sintaxe de comentário, a saber, #`(some bracket)que é um comentário com várias linhas até o colchete correspondente. Assim, o Perl 6 vê:
# comments
#`{
multiline comment
}# comment
print (7/6*24)# comment
que imprime 7/6*24 = 28.
Picolisp vê:
# comment
#{
multiline comment
}#(prin 29)
que imprime 29. A linha depois causa um erro de sintaxe.
TRANSCRIPT é um esolang temático modelado após aventuras de texto. Linhas não reconhecidas são ignoradas (o que permite adicionar texto extra de história / tipo entre as instruções reais do código), portanto, as linhas relevantes são:
Jo is here.
>Jo, 30
>X Jo
A primeira linha declara uma variável de string Jo, usando um nome de duas letras, pois os nomes de uma letra parecem falhar. A segunda linha define essa string como "30", que é emitida por X("examine") na terceira linha.
2.7.1a2.7.n. (Na verdade, sweerpotato faz exatamente isso com as versões principais.)