Escreva um pedaço de código que seja executável em pelo menos três idiomas diferentes. O código deve gerar o número inteiro 1no idioma número um, 2no idioma número dois, 3no idioma número três etc.

Regras:

• A saída deve ser apenas o número inteiro, mas as novas linhas finais estão OK.
• O código não pode receber nenhum tipo de entrada
• Diferentes versões principais do mesmo idioma são consideradas únicas. Portanto, seu código pode ser executável em Python 2 e Python 3, no entanto, Python 2.5 e Python 2.7 não são considerados únicos.
• Você pode usar um novo idioma se, e somente se, tiver um artigo esolang / wiki, intérprete e documentação disponíveis e tiver sido usado por pelo menos dois usuários no PPCG antes de usá-lo neste desafio. Ele também deve aderir a essas 4 regras .

A pontuação do seu envio é o número de bytes no seu código dividido pelo número de idiomas em que ele pode ser executado em cubos. Portanto, uma solução de 54 bytes que é executável em 3 idiomas terá uma pontuação de 2:

54 / 3^3 = 2  

Menor pontuação é melhor.

Entre os melhores

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 65641; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 31516; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d?\.?\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

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

1. VACA

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.

2. CoffeeScript (inclui intérprete)

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)}

3. Lisp Comum | ideona

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.

4. Retina | Experimente online!

^{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.

5. Befunge-93 | Intérprete

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.

6. Python 2 | ideona

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.

7. Rail | Experimente online!

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.

8. ETA | Experimente online!

^{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.

9. Prelúdio | Experimente online!

^{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.

10. Gol> <> | Intérprete

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.

11. mal | Experimente online!

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 ...

12. Foo | Experimente online!

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.

13. Ruby | ideona

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.

14. > <> | Experimente online!

Essa parte é a mesma que a parte Gol> <>, exceto que @os 14 chegam ao topo, que é gerado.

15. Brian e Chuck | Experimente online!

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.

16. espaço em branco | Intérprete

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.

17. 3var | Experimente online!

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.

18. Axo | Experimente online!

^{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.

19. labirinto | Experimente online!

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.

20. estrelado | Experimente online!

^{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.

21. Fissão | Experimente online!

A única parte relevante para a fissão é

*"12"L

Lgera um átomo se movendo para a esquerda, "21"imprime 21 e *pára.

22. Brainfuck | Experimente online!

^{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.

23. Julia | Experimente online!

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.

24. Lily | Intérprete

Lily vê:

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

7/6*24 = 1*24 = 24 é impresso.

25. GolfScript | Experimente online!

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.

26. esquema de frango | ideona

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.

27. qui | Experimente online!

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.

28. Perl 6 | ideona

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.

29. Picolisp | ideona

Picolisp vê:

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

que imprime 29. A linha depois causa um erro de sintaxe.

30. TRANSCRIÇÃO | Experimente online!

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.

15 idiomas, 68 66 65 bytes / 15 ^ 3 = 0,019 ...

Retina , Estrelado , Prelúdio , ETA , Axo , Labirinto , Hexagonia , Foo , Brian & Chuck , Gol> <> , mal , Espaço em branco , Fissão , > <> e GolfScript .

Após uma reescrita maciça, consegui me encaixar em mais quatro idiomas. O código contém as poucas guias do espaço em branco. Como o Stack Exchange os converte em espaços, eu os representei \tabaixo:

#I5aeeNTH{\?      \t\t + +3;n@"8"ea9
15}7'`--~!@<"31"LSOe.\t
 \teaww`

Acho que terminei de adicionar idiomas (embora a adição de apenas um possa salvar alguns bytes no que eu já tenho). Eu me pergunto se é possível jogar golfe ... 65 bytes para 15 idiomas é um salto de 32 bytes para 11 idiomas, e agora tenho pelo menos um caractere inútil para fazer o Foo funcionar.

Impressões de retina 1

Experimente online.

Felizmente, a primeira linha é um regex válido. No entanto, esse regex obviamente não corresponde à entrada vazia, portanto, o primeiro estágio (composto pelas duas primeiras linhas) não faz nada.

A terceira linha é por si só, portanto é tratada como um estágio de Correspondência que, por padrão, conta o número de correspondências. No entanto, `é um separador que informa à Retina que a parte à frente é uma sequência de configuração (não conhece nenhuma das opções fornecidas lá) e a parte depois é o regex. Portanto, o regex está vazio e Retina encontra exatamente uma correspondência.

Impressões estreladas 2

Experimente online.

Estrelado ignora tudo, exceto espaços e +*,'`.. Cada comando é um desses caracteres em conjunto com os espaços desde o último desses caracteres. Então, vamos remover todo o código estranho:

       + +'`. `

Sete espaços seguidos de +empurrões a 2. Um espaço seguido por um +duplicado. 'é um salto condicional. Ele aparece no topo da pilha, que é realmente positivo (positivo), e então pula para o rótulo correspondente (onde os rótulos são indicados por `e "correspondente" significa "com o mesmo número de espaços à esquerda"), que é o primeiro `. .sem espaços à sua frente, imprime a parte superior da pilha como um número.

Impressões de prelúdio 3

Experimente online.

Isso pressupõe o interpretador Python que usa saída numérica. Vamos remover todas as no-ops:

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

A primeira voz faz um monte de coisas, mas nada disso importa, porque não há !como imprimir nenhum dos resultados. A segunda voz empurra a 1, depois a 5e depois a 7. Tomamos a diferença dos dois últimos para obter -2e subtraímos isso do 1para obter 3. !imprime. A terceira voz tem apenas no-ops.

Impressões ETA 4

Experimente online.

O ETA ignora tudo, exceto os caracteres ETAOINSH(em qualquer caso). Portanto, o código visto pelo ETA é:

IaeeNTHneaSOeea

Itenta ler a entrada, mas não consegue, por isso empurra -1. aempurra o número da linha atual mais 1, que é 2. eé divmod , que substitui aqueles com 0e 1(ou -1, eu realmente não sei, mas isso não importa). O próximo esubstitui os dois por 0.

Agora a parte interessante. NTHneé um literal de número de base 7. Ne esão apenas os delimitadores e os três dígitos são THN. Ou seja 54(onde Té dígito 1, Hé 0e né 5). aempurra 2mais uma vez. Ssubtrai-o, resultando 52e Oemite-o como um caractere ( 4). Agora etenta divmod novamente, mas a pilha contém dois zeros, então o programa termina com um erro (mas não polui STDOUT enquanto o faz).

Impressões Axo 5

Experimente online.

Esse idioma foi praticamente o único responsável pela reescrita. Eu não poderia ter o }na primeira linha porque ele bloqueava a entrada no Axo (consulte o histórico de revisões do que estou falando). Para o Axo, apenas esta parte do código é relevante:

#I5aeeNTH{\

Felizmente, o Axo também tem 0s implícitos na parte inferior da pilha, porque #aparece a parte superior da pilha (para verificar se a próxima instrução deve ser ignorada ou não). As letras são todas não ops. Em seguida, 5pressiona a 5, {imprime e \finaliza o programa. Muito simples, realmente.

Impressões em labirinto 6

Experimente online.

Estou truncando o código um pouco, porque a metade direita nunca é alcançada e também estou usando tno lugar de \t, para que as colunas estejam alinhadas corretamente:

#I5aeeNTH{\
15}7'`--~!@
 teaww`

Agora que letras, espaços e tabulações são paredes no Labyrinth, o código acessível fica assim:

# 5      {\
15}7'`--~!@
      `

O ponteiro de instruções seguirá automaticamente esse caminho. #empurra a profundidade da pilha principal ( 0) e a 15transforma em a 15. }move-o para a pilha auxiliar e não vamos mais usá-lo. Isso convenientemente zera a parte superior da pilha, para que o IP não vire à esquerda na 5. 7transforma o zero em um 7, 'é um no-op. A `negação é unária, então chegamos -7. Agora -subtrai o -7do implícito 0abaixo dele 7. Desta vez, o IP vira à direita para o `, que é uma negação unária, então obtemos 7novamente. O IP atinge um beco sem saída e dá a volta. O -faz a mesma coisa que antes, então temos7mais uma vez. Como o topo da pilha agora é positivo, o IP vira à direita. Há outro -que dá -7novamente. Então ~é bit a bit NOT, que fornece 6e !imprime. Esse é apenas o momento certo para fazê-lo, porque agora a pilha está vazia novamente, de forma que o IP não vire à esquerda e, em {vez disso, continue em frente no @final do programa.

Impressões hexagonais 7

Experimente online.

O código desdobrado fica assim:

     # 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 . .
    . . . . . .
     . . . . .

Normalmente, isso seria um programa assustador do Hexagony, mas os caracteres atualmente em uso não são muitos. Na verdade, eles são praticamente iguais aos usados ​​pelo Labyrinth e acho que a maneira como eu diferencio 5e 6é bastante agradável. :)

A linha superior pode basicamente ser ignorada. #normalmente mudaria para um IP diferente, mas a borda da memória atual é 0, portanto não. As letras apenas definem um valor fixo de memória, mas não vamos usá-lo. Após o final da primeira linha, o fluxo de controle continua na linha do meio (começando pela }, indo para a direita). Os }move para outra borda de memória. 7define essa borda para 7. 'volta para onde viemos. -subtrai a borda da memória que acabamos de definir 7de uma borda da memória não utilizada ( 0), então obtemos -7. O próximo -faz a mesma coisa novamente, por isso é um não-op. Até agora, bem parecido com o Labirinto (além do layout da memória). Mas agora~não é bit a bit NÃO, mas negação unária no Hexagony. Então isso dá em 7vez de 6. !@, como em Labirinto, imprime o valor e finaliza o programa.

Impressões Foo 8

Experimente online.

Como todos sabemos desde a impressão do Quiz do Idioma de Programação , o Foo é bastante trivial, mesmo que a maior parte do código seja uma mistura aleatória de caracteres. Nenhum dos caracteres afeta a saída, exceto a "8"que é impressa 8. Bem, existe o "31"mais tarde, mas Foo termina com um erro no final da primeira linha. Não sei exatamente por que isso acontece, mas exige isso 3(ou qualquer outro dígito) na linha superior, que não é usada em nenhum outro lugar.

Brian & Chuck impressões 9

Experimente online.

Vamos fazer isso novamente quando removemos a terceira linha (nunca é analisada) e substituímos todos os caracteres irrelevantes (por exemplo, no-ops ou células que não são lidas) por espaços:

         { ?         + +         9
  }   --   <        .

Como lembrete, cada linha é do tipo Brainfuck cuja fita é o código fonte do outro programa. O fluxo de controle começa na primeira linha (chamada Brian).

Ele {move a cabeça da fita para a esquerda (onde ela já está) e o ?controle das mãos passa para Chuck (a segunda linha). Lá, }move a cabeça da fita para a direita até encontrar uma célula zero. Isso não acontece até o final do programa, então o cabeçote da fita termina uma célula após o 9. -diminui essa célula, mas isso é irrelevante. <move a cabeça da fita para a 9e .imprime. Chuck fica sem programa e termina.

Gol> <> impressões 10

Testado aqui.

#é um espelho, então o IP pula imediatamente para o final da primeira linha (e vai para a esquerda). O 9pode ser ignorado. aempurra 10, eempurra 14, "8"empurra o código de caractere de 8, @gira os três principais elementos da pilha (puxando para cima 10), de modo que nimprima 10e ;finalize o programa.

Agradecemos ao Sp3000 por sugerir o uso em @vez de !(que salvou um byte).

impressões do mal 11

Agradeço ao Sp3000 por me enviar algumas listas de comandos forçadas brutas para gerar números de um dígito.

Experimente online.

evil ignora tudo, exceto letras minúsculas, para que o código fique assim:

aeeneaeeaww

Além disso, nafeta algum estado com o qual não nos importamos, então vamos ignorá-lo também. Agora aincrementa o registro (que começa em 0) e eé a operação mágica de "tecer" do mal que permeia os bits de uma maneira particular. aeeeaeeapassa a produzir o valor 49que é o código de caractere 1. wwimprime duas vezes.

Impressões em espaço em branco 12

Experimente online.

Ok, sabemos que o Whitespace apenas lê espaços, tabulações e feeds de linha, então vamos escrever o código como visto pelo Whitespace com STL:

SSSSSSTTSSLTLST

São dois comandos:

SSSSSSTTSSL
TLST

O primeiro pressiona o número 12. Especificamente, SSinicia um número literal. O próximo Sé o bit do sinal (positivo). Então tudo até o Lé uma representação binária do número. Há uma tonelada de zeros à esquerda, que precisamos para Starry, mas eles não afetam o número. Então o TTSSs está 12em binário. Curiosidade: se eu adicionasse um idioma 16, poderia salvar um byte aqui, porque Starry poderia usar os quatro Sno represtado binário de 16. Duvido que sim ...

O TLSTapenas imprime a parte superior da pilha como um número. ( TLmarca o comando como um comando de E / S e STestá imprimindo números.)

Cópias de fissão 13

Experimente online.

A fissão vê apenas esta parte do código:

           <"31"L

Linicia o fluxo de controle com um átomo de esquerda. "alterna o modo de impressão, para que 31apenas imprima 13. Então o átomo é capturado na cunha do <, que finaliza o programa.

> <> impressões 14

Testado aqui.

Distinguir entre> <> e Gol> <> não é tão fácil quanto eu pensava, porque Gol> <> quase sempre faz a mesma coisa que> <> para comandos que existem em ambos e comandos que existem apenas em Gol> < > causar> <> travar. No entanto, @gira o contrário em> <>, de modo que empurra para baixo em 7vez de puxar para cima 10e, em seguida, 14é impresso em vez de 10.

Impressões GolfScript 15

Experimente online.

Essa é a mais simples: #comenta a primeira linha. Então se 15empurra e }é um "super comentário", que ignora todo o resto do programa. Portanto, o 15é impresso no final do programa.

Python 1.x, 2.xe 3.x, 32 bytes / 3 ^ 3 = 1.1851 ...

import sys
print(sys.version[0])

Imprime o primeiro número da versão, que está 1no Python 1.x, 2no Python 2.xe 3no Python 3.x.

Quando chegarmos ao Python 9.x, minha pontuação será gloriosa 0.04389!

: ~)!

3 idiomas, 2 bytes / 27 = 0,074

1P

Bem, supera pelo menos metade das finalizações: P

1. GolfScript

O GolfScript ignora o P, produzindo apenas o 1. Experimente online .

2. Par

Pé 2 à potência de, então 1P = 2^1 = 2. Experimente online .

3. Sério

Pdá o nono primo, zero indexado. Temos 3, já que é o segundo primo. Experimente online .

Notas

Meu objetivo inicial era encontrar uma resposta válida em 1 byte. Minha primeira tentativa foi a \x12que funciona em Bubblegum e gs2 , mas o desafio requer um mínimo de três idiomas. \x13funcionaria se houvesse um idioma em que isso produz 1.

Desistindo de uma resposta de 1 byte, mudei para dois bytes. 3ué por pouco, produzindo 1 em japonês , 3 em GolfScript e 4 em sério, mas era difícil encontrar uma linguagem que produzisse 2 para preencher a lacuna.

Tudo isso me levou muito tempo: /

6 idiomas - 44 bytes / 6 ^ 3 = 0,204 ...

Agradecimentos ao SnoringFrog por salvar 10 bytes!

Trabalha em:

• Befunge
• Pyth
• Brainfuck
• Hexagonia
• Espaço em branco
• AniRad v0.2

2# "1",@"-[----->+<]>.*@@@!4<SSTST
T
ST
 >6=

Nota: Antes de tentar online, certifique-se de substituir S por espaços e T por tabulações ou converter o seguinte hexdump em ASCII

32 23 20 22 31 22 2c 40 22 2d 5b 2d 2d 2d 2d 2d 3e 2b 3c 5d 3e 2e 2a 40 40 40 21 34 3c 20 20 09 20 09 0d 0a 09 0d 0a 20 09 0d 0a 20 3e 36 3d

Vou tentar usar mais linguagens de programação :)

Befunge (impressões 1):

Experimente online

2# "1",@"-[----->+<]>.*@@@!4<
2                             # This puts 2 onto the stack
 #                            # Skips the next op (the space)
   "1"                        # Sets the ASCII value of 1 onto the stack
      ,                       # Pop the last item (1)
       @                      # Terminate program

Pitão (impressões 2):

Experimente online

2# "1",@"-[----->+<]>.*@@@!4<
2                             # Prints 2
 #                            # Infinite while loop until an error occurs
   "1"                        # String
      ,@                      # This gives the error and terminates the program

Brainfuck (impressões 3):

Experimente online

2# "1",@"-[----->+<]>.*@@@!4<
2# "1",@"                     # Since these are not brainfuck ops, these will be ignored
         -[----->+<]>         # Puts "3" on the stack
                     .        # Prints the last item (3)     

Hexagonia (impressões 4):

Experimente online

2# "1",@"-[----->+<]>.*@@@!4<   

Uma versão mais legível:

   2 # " 1       # The steps:
  " , @ " -      # 1 (2) - Hexagony starts at the top-left of the hexagon
 [ - - - - -     #       - This immediately puts 2 onto the stack
> + < ] > . *    # 2 (#) - Since the stack is 2, this makes the 2nd pointer the 
 @ @ @ ! 4 <     #       - new current pointer
  > 6 = . .      # 3 (*) - The position of the 2nd pointer is in the left-most
   . . . .       #       - position. This sets the stack to the product
                         - of the two neighbours which is zero
                 # 4 (<) - Changes the pointer direction to west
                 # 5 (4) - Sets the stack to 4
                 # 6 (!) - Outputs the decimal 4
                 # 7 (@) - Terminates the program

Espaço em branco (impressões 5):

Experimente online

Como outros caracteres são ignorados, mas os espaços em branco e as guias são deixados com o seguinte:

SSTST                 # This pushes 5 onto the stack
T                     # 
ST                    # This prints the decimal

AniRad versão 0.2 (impressões 6):

De alguma forma, isso funciona para a versão 0.2, mas fornece um erro para a versão 0.4. Eu não tenho idéia do porquê. Você pode encontrar a versão 0.2 aqui . Para executar isso, você pode copiar e colar o código do intérprete para repl.it e executá-lo. Depois disso, você só precisa colar o programa no STDIN e executá-lo.

2# "1",@"-[----->+<]>.*@@@!4<      # (#)  Starts at the hashtag (starting point)
                                   #      Direction is down
                                   # (>)  When the pointer gets to the '>', it changes
 >6=                               #      its direction
                                   # (6) Puts 6 onto the stack 
                                   # (=) Pushes the result and terminates

6 7 idiomas, 32 37 bytes, pontuação 0,148 ... 37/7 ³ ≈ 0,107872 ...

#7+!"@\"6.@;n5
print(4--int(-3/2)#"
)

Brainfuck-ng

+incrementa a célula atual, !imprime como número inteiro e @sai. #e "são NOPs.

Python 2

A primeira linha é o comentário. Usando a divisão inteira, calcula 4 - -int(-3 / 2) = 4 - -int(-2) = 4 - -(-2) = 4 - 2 = 2e imprime o resultado.

Python 3

O mesmo que o anterior, mas com divisão de flutuação. 4 - -int(-3 / 2) = 4 - -int(-1.5) = 4 - -(-1) = 4 - 1 = 3.

Lua

--inicia um comentário e, #na primeira linha, há um comentário, basicamente print(4).

> <>

#reflete IP, 5pressiona 5, nimprime um número e ;sai.

Befunge

#pula o mouse +, !anula logicamente o topo da pilha, "@\"empurra a corda @\, 6empurra 6, .imprime um número e @sai.

Pyth

#inicia um loop infinito, descartando erros. 7imprime 7, depois segue o +!"string")que basicamente causa um erro por não ter dois operandos para +finalizar o programa.

JavaC ++ C, 363/27 = 13,4 ....

Java imprime 1, C ++ imprime 2, C imprime 3. Não quebrando nenhum registro aqui (porque Java), mas eu realmente gosto da maneira inteligente e abusiva de criar poliglotas nessas linguagens que descobri.

//\u000a/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*\u002a/
import static java.lang.System.out;
public class P{//*/
/*\u002a/public static void//*/
main(/*\u002a/String[] args//*/
){//\u000a/*
out.print=p;
//\u002a/
out.print(1);}
/*\u002a/}//*/

Isso é uma bagunça. Aqui está um detalhamento de como funciona. Os literais Unicode ( \u000atambém conhecidos como avanço de linha e \u002atambém conhecidos como *) são expandidos pelo compilador Java em seus caracteres reais. Então, aqui está o que o compilador Java vê:

//
/*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/**/
import static java.lang.System.out;
public class P{//*/
/**/public static void//*/
main(/**/String[] args//*/
){//
/*
out.print=p;
//*/
out.print(1);}
/**/}//*/

Todas essas coisas no começo são ignoradas porque estão agrupadas em um comentário de várias linhas ( /* ... */). Posteriormente, vemos que a mistura de comentários de uma linha e de várias linhas nos permite controlar exatamente quais partes são comentadas em cada idioma. No método principal, iniciamos um comentário com várias linhas e, em seguida, temos //*/. Normalmente, esse seria um comentário de linha única, mas, como estamos em um comentário de várias linhas, //ele não faz nada, permitindo */que ele seja fechado.

Este é o código Java equivalente, com os comentários removidos:

import static java.lang.System.out;
public class P{
public static void
main(String[] args
){
out.print(1);}
}

Aqui está o que o compilador C / C ++ vê (removi os literais Unicode, pois eles não são expandidos pelo compilador e, portanto, não fazem nada):

///*
#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
//*/
/*/
import static java.lang.System.out;
public class P{//*/
/*/public static void//*/
main(/*/String[] args//*/
){//\/*
out.print=p;
///
out.print(1);}
/*/}//*/

Aqui, os comentários de linha única substituem os delimitadores de comentário de várias linhas no início, para que todos #defineos #includese pré-processem. Em seguida, comentários de várias linhas são usados ​​para comentar o código de padrão para Java. Este é o código equivalente, com os comentários removidos:

#include<stdio.h>
#ifdef __cplusplus
#define o "2"
#else
#define o "3"
#endif
int p(int a){printf(o);}
struct{int(*print)(int);}out;
main(
){
out.print=p;
out.print(1);}

Um truque poliglota C / C ++ padrão (the #ifdef __cplusplus) é utilizado para definir um token ocomo um "2"ou "3", dependendo se é um compilador C ++ ou C que está compilando o código. Em seguida, definimos uma função pque recebe um único intargumento (ignorado) e chama printf, usando nosso otoken recém-definido . Como de costume, o valor de retorno é deixado de fora, pois não estamos no modo estrito. Em seguida, definimos a structcom um único membro, um ponteiro de função cuja assinatura corresponde pa e construímos uma única instância chamada out. No método principal (deixamos de lado o inthabitual), o endereço de pé atribuído a out.print(assim out.printchamadas p) e é chamado.

Se o C ++ não estivesse incluído nas linguagens, poderíamos descartar todo o código do pré-processador e definir pcomo int p(int a){puts("2");}. Infelizmente, o C ++ requer uma #includeE / S de execução. Se C não estivesse incluído, poderíamos descartar a definição pe a #ifdefmacro do pré - processador e definir diretamente uma função de membro no structlugar de precisar de um ponteiro de função. Infelizmente, C não suporta funções membro.

4 idiomas, 28 bytes / 64 = 0,4375

print((0 and 3^1or 1/2>0)+1)

1. Python 2

0é falso e /é divisão inteira, então

(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0 > 0) + 1 = False + 1 = 1

2. Perl (também Python 3)

0é falso e /é divisão de flutuação, então

(0 and 3^1 or 1/2 > 0) + 1 = (1/2 > 0) + 1 = (0.5 > 0) + 1 = 1 + 1 = 2

3. Ruby

0é verdade e ^é bit a bit xor, então

(0 and 3^1 or 1/2 > 0) + 1 = xor(3,1) + 1 = 2 + 1 = 3

4. Lua

0é verdade e ^é exponenciação, então

(0 and 3^1 or 1/2 > 0) + 1 = pow(3,1) + 1 = 3 + 1 = 4

Observe que Lua e Ruby não podem adicionar booleanos como se fossem números inteiros, daí o agrupamento deles. Infelizmente 0and, não funciona em Lua, por isso não podemos salvar um byte lá.

Versão anterior de 17 bytes, que imprime 1 (Lua), 2 (Ruby), 3 (Python / Perl):

print(2^(0 or 1))

-3 bytes graças a @xnor para esta versão, tornando-a muito mais limpa :)

BFSRS> <> funge93thon123, 73/343 ≈ 0.212827 ...

Brainfuck, Sério ,> <>, Befunge-93, Python 1, Python 2, Python 3

# 4['.]@kX21z-[>+<-----]>--.<;n3
import sys;print(3+int(sys.version[0]))

Contém imprimíveis, hexdump (reversível com xxd -ps -r):

2320345b272e5d406b5832317a7f2d5b3e2b3c2d2d2d2d2d5d3e2d2d2e3c
3b6e330a696d706f7274207379733b7072696e7428332b696e7428737973
2e76657273696f6e5b305d2929

Adicionarei mais idiomas (e provavelmente bytes) ao longo do tempo. Os idiomas no cabeçalho são listados na ordem em que são impressos. Assume células de quebra automática de 8 bits e uma fita que não se queixa de sair da posição inicial (quebra automática ou infinita) para Brainfuck.

Brainfuck:

[.]   initial value of first cell is 0, so loop is skipped
-[>+<-----]>--  push 49 (ASCII ordinal of 1)
.     print "1"
<     move to blank cell
[0]   skip loop because cell is 0
      everything else is ignored

Sério :

# 4['.]@  does some stuff we don't care about
kX        pop entire stack, push as list, discard (essentially the same as é, but is ASCII so we can use Python)
2         push 2
1z        pop 1 item from stack and print (used instead of . so Brainfuck doesn't print here; same as ü in this scenario, but is ASCII so we can use Python)
0x7f      terminate program
          everything else is ignored

><>:

#    mirror, reverse direction
3n;  push 3, print "3", end (reversed because IP is scanning RTL at this point)
     everything else is ignored

Befunge-93:

#     jump over the space
4['.] push 4, print 4 (brackets and ' do nothing)
@     end program
      everything else is ignored

Python 1 (graças ao muddyfish):

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+1=5

Python 2 :

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+2=6

Python 3 :

# 4['.]@kX21z-[>+<-----]>--.<;n3         comment; ignored
import sys;print(4+int(sys.version[0]))  prints 4+3=7

14 idiomas, 73 bytes, pontuação = (73/14 ^ 3) = 0,02660349854

#Y2(3`5n~thneo e        ;n@0d c
#   -[>+<"9"L-----]>+.
14  
print(int(15/2))+3

Posso adicionar mais alguns langs, mas acho que vou adicionar o que tenho aqui.

1. Brainbool ; Experimente online!

O código relevante:

    [>+<         ]>+.

               + 

Isso é realmente justo +.+, o que gera 1.

2. Jolf ; Experimente aqui!

O (char para de interpretar o código fonte, portanto, o código relavent é:

#Y2

Isso é equivalente a (em JavaScript)

var Y = []; toHex(Y); alert(2);

Qual saída 2.

3. elemento; Experimente online!

O código relevante:

    3`

Isso captura 3e imprime.

4. Brainfuck ; Experimente online!

O código relevante é:

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

  -    -      + 

Qual é a maneira padrão de gerar o código de char do 4 e produzi-lo, e algumas outras coisas depois dele.

5. Reng; Experimente aqui!

~ finaliza o programa, então o código relevante aqui é:

#Y2(3`5n~

#redefine Ypara ser o TOS, neste caso 0,. 2empurra 2; (gira a pilha N vezes, pressionando N da pilha; 3`empurra -3; e, finalmente, 5nimprime 5.

6. ETA; Experimente online!

O ETA lê apenas as letras E, T, A, O, I, N, S, H, portanto, o código executado apenas é o seguinte:

       n thneo e         n     


  int int          

Código super-relevante:

       n thneo

Ou, de forma equivalente: nthne o. n...eé um literal de base 7 e thné o número base 7 de 54. ogera esse caractere. A submissão falha, mas não sei por que.

7. Python 3

O que vê:

# comment
# comment
14
print(int(15/2))+3

15/2produz 7,5, como /é a divisão de flutuação. int(...)torna o número um int, que é impresso. O programa falha quando +3é encontrado.

8. Julia

Julia vê:

# comment
# comment
14
print(int(15/2))+3

Em vez de truncar 15/2, Julia o arredonda, produzindo 8. Ele imprime isso e depois erros ao encontrar +3.

9. fissão; Experimente online!

Código relevante:

        <"9"L         

Eu recebi essa idéia da parte da Fissão de Martin (mais como roubada). Lcomeça uma coisa voltada para a esquerda, captura 9e termina com <.

10. espaço em branco; Experimente aqui!

O código relevante, traduzindo espaços Se tabulações em T:

SSSTSTS
T
ST

Empurra 10 para a pilha e a produz como um número ( T\nST).

11. Python 2

O Python 2 vê isso:

# comment
# comment
14
print(int(15/2))+3

(int(15/2))+3 é avaliado como 11 e é impresso.

12. Gol> <>; Experimente aqui!

Código relevante:

#                      ;n@0d c

Isso usa o truque usado na resposta de Martin que @gira diferentes direções em> <> e Gol> <>. #espelha, cempurra 12, dempurra 13, 0empurra 0 e @leva cpara o topo da pilha, sendo depois retirado e impresso ;n.

13.> <>; Experimente online!

Código relevante:

#                      ;n@0d c

Novamente, o uso que @gira diferentes direções em> <> e Gol> <>. #espelha, cempurra 12, dempurra 13, 0empurra 0 e @leva dpara o topo da pilha, sendo depois retirado e impresso ;n.

14. Golfscript; Experimente online!

O que vê:

# comment
# comment
    14
print(-int(-15/2))+3

Empurra 14, prints it e erros. Roubado inspirado pela resposta do Sp3000 .

Subskin , Brainfuck e Fob 27 bytes / 3 ^ 3 = 1

0#>&$3#<>$-[----->+<]>-.
31

Subskin

0
31

Definimos o ponteiro da instrução (não importa aqui) para 0e o registro de saída como 31. Se o conteúdo do registro de saída for >= 0, emitimos o valor contido como a char. Todos os outros códigos são ignorados.

Brainfuck

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

Coloca 3no registro, diminui o valor uma vez com -e finalmente gera com ..

Fob

#>&$3#<>$

Isso é um pouco mais complicado, pois o Brainfuck também lê as instruções <e >no Fob. Entramos no modo de execução #e aumentamos o ponteiro de Brainfuck em um que facilite mais tarde. Ainda não temos nada para executar, então nada é executado.

Entramos no modo acumulador com $, lançamos a 3, entramos no modo de execução novamente, empurramos o conteúdo do acumulador para a pilha <e, finalmente, produzimos o conteúdo com >.

Para evitar que o Brainfuck estrague o programa, entramos no modo de acumulação novamente com $.

7 idiomas, 55/7 ^ 3 ≈ 0,16035

Executa no PowerShell v1, v2, v3, v4 e v5, Foo e Pyth

#7.q"6""
$p=$PSVersionTable;($p.PSVersion.Major,1)[!$p]

Os dígitos 1 a 5 usam lógica semelhante à resposta da batata doce . A $PSVersionTablevariável especial foi introduzida no PowerShell v2 e contém uma lista completa de compilações, revisões, etc. Aqui está um exemplo de saída da variável:

PS C:\Tools\Scripts> $PSVersionTable

Name                           Value                                                                                                                           
----                           -----                               
PSVersion                      4.0
WSManStackVersion              3.0
SerializationVersion           1.1.0.1
CLRVersion                     4.0.30319.34209
BuildVersion                   6.3.9600.17400
PSCompatibleVersions           {1.0, 2.0, 3.0, 4.0}
PSRemotingProtocolVersion      2.2

Nesse código, primeiro o armazenamos $ppara que o tamanho do código seja menor. Em seguida, verificamos sua existência, alavancando a variável como um índice em uma matriz de dois itens:

• Se a variável não existir, o PowerShell a criará e atribuirá dinamicamente $NULL, o !que é $TRUE, ou 1, que corresponde ao segundo elemento da matriz, que é gerado 1.
• Se a variável existir (como é o caso na v2 +), !a variável resultará em $FALSEou 0, que indexa o primeiro elemento, que gera o número da versão.

Usando o Foo for 6, aproveitamos esse #comentário no PowerShell, que é ignorado ao executá-lo em um ambiente PS. No entanto, Foo felizmente cuspir o número 6e, em seguida, prosseguir com o resto do programa, o que não faz nada.

Usando Pyth for 7, retornamos 7e imediatamente encerramos com .q, para que o loop infinito while-true que começou com #não importa. Como ainda temos algo que é impresso implicitamente. Obrigado a @ FryAmTheEggman por esta adição.

_{Edit - Golfed um punhado de bytes graças a Mauris Edit - esclareceu Pyth explicação graças a Sp3000}

7 idiomas, 287/7 ^ 3 = 0,836

Provavelmente a pontuação mais baixa que aparece, de qualquer maneira eu gosto dessas 3 versões do poliglota C.

Adicionada a solução Python chata para pelo menos se qualificar para a recompensa de "3 idiomas únicos".

Adicionado Java abusando dos trigramas C para diferentes interpretações de comentários.

Trabalha em:

• Python 1

• Python 2

• Python 3

• C89

• C99

• C ++

• Java

versão golfed:

/*
*??/
/
#include <stdio.h>
#ifndef __cplusplus
#define true 8/*
import sys
print(sys.version[0])
'''
#*??/
/
#endif
int main(){int a=(true>1)?-6:3;printf("%d",(true//*
+a
//**??/
/+2));}
#define a \
'''
/**\u002f
public class p{public static void main(){System.out.println("7");}}
/**/

Ungolfed:

/*
*??/
/

#include <stdio.h>

#ifndef __cplusplus
#define true 8/*

import sys
print(sys.version[0])
'''
#*??/
/
#endif 

int main()
{
    int a = (true > 1) ? -6 : 3;
    printf ("%d", (true//*
    +a
    //**??/
/
    +2));
}
#define a \
'''

/**\u002f
public class p
{
    public static void main()
    {
        System.out.println("7");
    }
}
/**/

Ok, isso provavelmente está ficando meio estranho e espero que minhas habilidades em inglês sejam boas o suficiente para explicar isso de maneira comum.

Antes de tudo, vou explicar os diferentes tipos de comentários que usei para encapsular as estruturas de linguagem, cada uma por si.

Então vamos pegar o primeiro bloco:

/*
*??/
/

Para Java, este é apenas o começo de um comentário de várias linhas. Mas ... em C99 / 89 / ++, isso avalia como

/*
*/

Como ??/é um trígrafo por \enquanto em C, o \caractere é meio consistente e até consome quebras de linha em sua funcionalidade de comando. Isso faz com que o resultado de um \nseja apenas "exibido" em vez de apresentar quebras de linha. isso significa que, considerando a matriz de bytes que representa o primeiro bloco: [ /] [ *] [ \n] [ *] [ ?] [ ?] [ /] [\n ] [ /]] seria após a avaliação do trigrama: [ /] [ *] [ \n] [ *] [ \] [ \n] [ /] [ ] Onde a funcionalidade consistente dos \gatilhos e "consome", os \nbytes avaliados restantes e finais em C langs são: [ /] [ *] [ \n] [ *] [ /] [ ]

Mas tudo isso java não sabe nada e trata tudo o que se segue como um comentário até que esse truque seja revertido.

(continua!)

4 idiomas (Befunge-93, Microscript II, Microscript e Foo), pontuação 7/64 = 0,109

"4"1.@2

Melhor: Pressione 4, pressione 1, imprima 1 e termine.

Microscript II: Produza a string "4", descarte-a, pegue a raiz quadrada de uma, descarte-a e, finalmente, defina x como 2. Isso é impresso implicitamente.

Microscript: pressione 52 na pilha (que nunca será realmente usada pelo restante do programa), aumente o registro (inicialmente zero) em um e, em seguida, aumente o registro em dois. Isso é impresso implicitamente.

Foo: Imprima a string "4" e pressione 2

Python 1 | 2 | 3, 27 bytes / 27 = 1

print(len("\xabc")+(1/2>0))

O uso de números de versão pelo @wewepotato me fez pensar se era possível distinguir os Pythons em menos. Aqui está o melhor que eu encontrei.

Explicação

Para distinguir o Python 3 das versões anteriores, usamos o truque de divisão inteira padrão vs. divisão de ponto flutuante. (1/2>0) == (0>0)retorna 0 pré-Python 2.3 ou a Falsepartir do Python 2.3 em diante e (1/2>0) == (0.5>0)retorna Truepara o Python 3.

Para distinguir o Python 1 do resto, pegamos o comprimento da string "\xabc", que é o comprimento um no Python 1 e o comprimento dois do Python 2 em diante. Por quê? Porque

O escape \ x em literais de string agora leva exatamente 2 dígitos hexadecimais. Anteriormente, consumia todos os dígitos hexadecimais após o 'x' e pegava os 8 bits mais baixos do resultado, portanto \ x123456 era equivalente a \ x56.

(Do que há de novo no Python 2.0 )

Python 3, Ruby, Perl, C, C ++, Objective-C 202 bytes / 6 ^ 3 = 0,935 ...

Isso foi bastante divertido, na verdade, e muito jogo com booleanos.

Você pode todas as versões do código no site a seguir , copiando e colando o código no intérprete.

#include <stdio.h> /*
print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1
"""""
*/
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}/*
"""
#*/

Python 3, impressões 1

O truque é o seguinte:

print ((("0"+"0"==0)and 3) or (0and 2or 1));

Isso imprimirá 1

Ruby, impressões 2

O código interpretado para Ruby é:

print ((("0"+"0"==0)and 3) or (0and 2or 1));

Então isso imprime 2

Perl, impressões 3

O código interpretado para Perl é:

print ((("0"+"0"==0)and 3) or (0and 2or 1));
__DATA__ = 1

Primeiro, o __DATA__token informa ao compilador Perl que a compilação foi concluída. Tudo depois é ignorado.

print ((("0"+"0"==0)and 3) or (0and 2or 1));

E imprime 3

C, impressões 4

O código interpretado é bem diferente dos outros:

#include <stdio.h>
int main(){putchar(
#ifdef __OBJC__
'6'
#else
#ifdef __cplusplus
'5'
#else
'4'
#endif
#endif
);return 0;}

Isso simplesmente imprimirá o caracter 4.

C ++, impressões 5

O mesmo que o código C

Isso imprimirá o caracter 5.

Objetivo-C, impressões 6

O mesmo que o código C

Isso imprimirá o caracter 6.

5 idiomas, 18 bytes / 5 ^ 3 = 0,144

É executado em Brainbool , Mathematica , Foo , > <> e Befunge-93 .

4!<n;+Print@2"3".5

Brainbool

O Brainbool é como o Brainfuck, mas opera apenas em bits, e sua entrada e saída consistem apenas em 0e 1.

4!<n;+Print@2"3".5
  <                   move the pointer to the left
     +                logic not
                .     print the current cell

Mathematica

No Mathematica, tudo é uma expressão e tem um valor. Print@2imprime 2e retorna o símbolo Null. Depois disso, o código faz alguns cálculos simbólicos, mas não imprime nada.

Foo

"3" impressões 3. Não sei o que as outras partes fazem.

> <>

4!<n;+Print@2"3".5
4                     push 4
 !                    skip the next command
   n                  pop and print it as a number
    ;                 end the program

Befunge

4!<n;+Print@2"3".5
4                     push 4
 !                    logical not
  <                   makes the program counter travel to the right
 !                    logical not
4                     push 4
                 5    push 5
                .     pop and print it as a number
             "3"      push the string "3"
            2         push 2
           @          end the program

Usando o truque de sweerpotato , barato, mas poderoso.

Executa no Brainbool , Mathematica 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0 e 10.0 , Foo e > <> .

cn;+"11".Print@Floor@$VersionNumber

6 idiomas, 38/6 ^ 3 = 0.17592̅5̅9̅

Espaço em branco , Brainfuck, Rubi, Labirinto , Foo, Seriously

Lenda:

£: aba

•: espaço

§: 0x7f

puts•2;#4!@•-[>+<-----]>6.§"5"•£    
£
•£

Contém caracteres não imprimíveis, então aqui está o hexdump:

7075747320323b23342140202d5b3e2b3c2d2d2d2d2d5d3e362e7f22352220090a090a20090a

Explicação:

Espaço em branco

Experimente online. (Nota: meu programa omite os três feeds de linha de fechamento para finalizar o programa, eu escrevi / testei isso no Whitelips e produz a saída correta lá, mas não no Try It Online, portanto, o programa vinculado tem esses dois caracteres adicionados. como posso dizer, alguns intérpretes permitem que você faça isso, outros ficam presos em um loop infinito sem a terminação explícita)

(omitindo caracteres ignorados)

spacespacespacetabenter: empurre um 1 para a pilha

tabenterspacetab: gera a parte superior da pilha

Rubi

Não deveria precisar de explicação. Imprime 2, trata o restante dessa linha (ergo, o programa de foda cerebral) como um comentário, trata o restante do arquivo como vazio.

Brainfuck

Experimente online.

Requer um intérprete que suporte o fluxo insuficiente. Subflui a primeira célula para 255 e a usa para um contador de loop gerar 51, que é o código ascii para 3.

Labirinto

Experimente online.

(omitindo as duas últimas linhas por legibilidade, porque elas nunca são alcançadas)

puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•                            skipped
     2                           push 2 onto stack
      ;                          pop 2 from stack
       #                         push current stack depth (0) to stack
        4                        push 4 to stack
         !                       print top of stack as integer
          @                      program terminates

Foo

Experimente online.

A única coisa que afeta a saída é "5", que imprime 5.

A sério

Experimente online.

puts•2;#4!@ -[>+<-----]>6.§"5"•£
puts•2;#4!@ -[>+<-----]>           assorted stack manipulation that doesn't affect this program
                        6          push 6 to the stack
                         .         output top of the stack
                          §        (0x7f) terminate program

5 idiomas, Chaîne , Minkolang , Foo , Brainf ** k-ng e Vitsy , 21/5 ^ 3 = 0,168

2|<«+!@"3".N+m

5N»

Brainf ** k-ng

2|<«+!@"3".N+m

5N»
  <            go left (should still be ok)
    +!         output 1
      @        halt execution

Chaîne

2|<«+!@"3".N+m

5N»
2              «add 2 to the current string»
 |<            «take off and put on the string (no op)»
   «           «comment»

  »
               «implicit output»

Foo

2|<«+!@"3".N+m

5N»
       "3"     print three

Minkolang

2|<«+!@"3".N+m

5N»
2              C push 2 to the stack [2] C
 |             C mirror C
2              C push 2 to the stack [2,2] C
             m C ignored C
            +  C add top two [4] C
           N   C output C
          .    C terminate program C

Vitsy

2|<«+!@"3".N+m

5N»
2              push 2
 |             mirror
2              push 2
             m pop 2, goto line 2
5              push 5
 N             output 5
  »            ignored

Provavelmente posso adicionar> <> ou algo assim.

Craneflak , Brain-Flak Classic , Rain-Flak , BrainHack , Brain-Flueue , miniflak , miniHack : .1020

(([]()()()<()()()>)()()){}#{}({}())

Experimente online!

Explicação

A primeira coisa acontecendo aqui é que há uma diferença na maneira como os comentários são lidos entre os intérpretes BrainHack, CraneFlak e Rain-Flak. Craneflak não tem comentários, no Rain-Flak #comenta o resto da linha e no BrainHack #{...}comenta o interior.

Então, aqui está o que cada idioma lê:

Rain-Flak: (([]()()()<()()()>)()()){}         -> 3
BrainHack: (([]()()()<()()()>)()()){}({}())   -> 4
Craneflak: (([]()()()<()()()>)()()){}{}({}()) -> 1

A próxima coisa é a diferença entre os flocos cerebrais e os miniflaques. O Rain-Flak e o BrainHack suportam miniflak, onde todas as operações extras são simplesmente removidas. Isso significa que eles perdem a []e<...>

Rain-Flak: (()()()()()())         -> 6
BrainHack: (()()()()()())({}())   -> 7

A seguir, temos a diferença entre o Brain-Flak e o Brain-Flak Classic. Em clássico []é -1em vez da altura da pilha, o que significa que o nosso resultado é 1 a menos do que em regular de Rain-Flak, fazendo 2.

Por fim, temos a diferença entre Flak cerebral e Flue cerebral. Na combustão cerebral, uma fila é usada em vez de uma pilha. Normalmente, o ataque cerebral empurra 3 e 5 e retira os 5, no entanto, no escape cerebral, o pop se livra dos 3 e não dos 5.

Via Láctea 1.0.2 , CJam e STXTRM , 20 bytes / 3 ^ 3 = 0,741

Eu imagino que há pelo menos um outro idioma que eu poderia adicionar.

'2"3""1"1<<1>;;"2"3;

Explicação

Via Láctea ,1

Na Via Láctea, as strings são apenas indicadas por pares de aspas duplas. Uma aspas simples lê a entrada da linha de comando; se não houver, ele envia uma string vazia. Sinais maiores que e menores que girarão a pilha inteira para a direita e para a esquerda, respectivamente. Finalmente, um ponto-e-vírgula troca os dois principais elementos da pilha.

Aqui está uma visualização de pilha (a pilha mostrada é o resultado da operação listada após a ocorrência):

["", 0]                                             #  default stack

["", 0, ""]                                 #   '   #  read input from command line
["", 0, "", 2]                              #   2   #  push 2 to the stack
["", 0, "", 2, "3"]                         #  "3"  #  push "3" to the stack
["", 0, "", 2, "3", "1"]                    #  "1"  #  push "1" to the stack
["", 0, "", 2, "3", "1", 1]                 #   1   #  push 1 to the stack
[0, "", 2, "3", "1", 1, ""]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0]                 #   <   #  rotate the stack leftwards
["", 2, "3", "1", 1, "", 0, 1]              #   1   #  push 1 to the stack
[1, "", 2, "3", "1", 1, "", 0]              #   >   #  rotate the stack rightward
[1, "", 2, "3", "1", 1, 0, ""]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0]              #   ;   #  swap the top two stack elements
[1, "", 2, "3", "1", 1, "", 0, "", 2]       #  "2"  #  push 2 to the stack
[1, "", 2, "3", "1", 1, "", 0, "", 2, "3"]  #   3   #  push "3" to the stack
[1, "", 2, "3", "1", 1, "", 0, "", "3", 2]  #   ;   #  swap the top two stack elements

CJam ,2

No CJam, as strings também são indicadas por pares de aspas duplas. Uma aspas simples envia o código do caractere a seguir. Quando um código de caractere é produzido, ele é produzido como seu caractere correspondente. Sinais maior que e menor que agem como esperado, avaliando a ordem dos dois principais elementos da pilha. Finalmente, um ponto-e-vírgula descarta o elemento da pilha superior. No término do programa, o conteúdo da pilha é gerado.

Aqui está uma visualização de pilha (a pilha mostrada é o resultado da operação listada após a ocorrência):

[]                         #  default stack

['2]               #  '2   #  push the character code of "2" to the stack
['2, "3"]          #  "3"  #  push "3" to the stack
['2, "3", "1"]     #  "1"  #  push "1" to the stack
['2, "3", "1", 1]  #   1   #  push 1 to the stack
['2, "3", "1"]     #   <   #  leave the greater of the top two stack elements on the stack
['2, 0]            #   <   #  leave the greater of the top two stack elements on the stack
['2, 0, 1]         #   1   #  push 1 to the stack
['2, 1]            #   >   #  leave the lesser of the top two stack elements on the stack
['2]               #   ;   #  pop the top stack value
[]                 #   ;   #  pop the top stack value
['2]               #  "2"  #  push the character code of "2" to the stack
['2, "3"]          #   3   #  push "3" to the stack
['2]               #   ;   #  pop the top stack item

STXTRM ,3

No MSM, qualquer coisa que não seja um operador é enviada para a pilha como um caractere. Um ponto-e-vírgula duplica o elemento da pilha superior. O programa continua até que não haja mais operadores ou que haja um único elemento na pilha.

O caractere final na pilha 3é duplicado pelo operador final. 3é o elemento mais alto no final do programa, portanto é emitido.

5 idiomas, 18 bytes / 5 ^ 3 = 0,144

Ouroboros , Pip , QBasic, Foo e Pyth

5'"4"()"
1?3'@n()2

1. Ouroboros

Cada linha do programa representa uma cobra comendo seu rabo.

Cobra 1

Push 5, 'é um push não operacional 52(código ASCII de "4"). (faz com que a cobra estale um número e coma tantos caracteres de sua cauda. Como isso resulta na ingestão do ponteiro de instruções (e de toda a cobra), a execução é interrompida.

Cobra 2

Empurre 1, empurre um número aleatório ( ?), empurre 3, 'é um no-op. @gira o 1para o topo da pilha e o ngera como um número, deixando o 3topo da pilha. Depois (come tantos caracteres do final da cobra, engolindo o ponteiro da instrução e interrompendo.

Você pode executar este programa on-line no interpretador de snippet de pilha aqui .

2. Pip

A maior parte do programa consiste em expressões que são avaliadas e descartadas:

• 5
• '" (literal de caractere)
• 4
• "()"
• 1?3'@ (expressão ternária)
• n (variável, = nova linha)
• () (nada)

Finalmente, a última expressão 2,, é impressa.

3. QBasic

Tudo depois 'é um comentário. A primeira linha resume-se a 5um número de linha. Na segunda linha, 1é um número de linha e ?3é um atalho para PRINT 3.

^{(Aparentemente, ter números de linha fora de ordem não é um problema, embora seja fácil corrigi-lo.)}

4. Foo

Quase tudo é sem ops. "4"impressões 4. Os parênteses (x2) são um loop que é executado até que a célula atual da matriz seja zero, o que é verdadeiro imediatamente e o loop sai. @, quando não é seguido por um número, pega o valor da célula da matriz atual (inicializada em 0) e a envia para a pilha.

Não tenho muita certeza de como o segundo, incomparável, "deve ser tratado. A versão online parece adicionar uma nova linha à saída, permitida pelas regras do desafio.

5. Pitão

5é produzido. Em seguida, o programa encontra '"4", que tenta ler de um arquivo chamado 4. Enquanto esse arquivo não existir, acho que isso deve encerrar o programa com um erro. (A versão online diz name 'open' is not defined- presumo que abrir arquivos não é permitido online).

A dispersão "no final da linha 1 garante que a linha 2 não cause um erro de sintaxe antes da execução.

4 idiomas, 24 bytes, 24/4 ^ 3 = 0,375

print(1//0.5--1+1/2*2
);

1. PHP

PHP executa o print(1);que é igual a 1

2. Lua

Lua executa o print(1//0.5);que é igual a 2

3. Python 2

Python 2 executa print(1//0.5--1+1/2*2);igual a 3 (divisão inteira)

4. Python 3

Python 3 executa print(1//0.5--1+1/2*2);igual a 4 (divisão flutuante)

Brainfuck-ng, Foo,> <>, 9 bytes / 3 ^ 3 = 0,333 ...

#+!"2";n3

Brainfuck-ng

Os únicos caracteres que reconhece são +e !:

+ Increment cell by one
! Print as integer

Impressões 1

Foo

Imprime tudo entre aspas.

"2"

Impressões 2

> <>

#Espelha o ponto à esquerda, 3empurra 3 para a pilha, ngera como um número inteiro, ;interrompe o programa.

#      ;n3

3 idiomas, 82 83/3 ^ 3 = 3,074 ...

Trabalhos em ??? , Espaço em branco e Beatnik . Ou melhor, deve funcionar nesses idiomas, mas não poderei testá-los por alguns dias. Enfim, aqui está o código:

K... Jax... Jy... Jy...   ...
My...    My...
... ...     ......................XO!

1. ???

.................................................!

??? é basicamente foda cerebral, mas usa pontuação comum como comandos, em vez dos caracteres tradicionais. .incrementa a célula de memória atual, feita 49 vezes. !pega a célula de memória atual e a imprime como um caractere, aqui 1.

2. Espaço em branco

[Space][Space][Space][Tab][Line Feed]
[Tab][Line Feed]
[Space][Tab]

Espaço em branco é uma linguagem que ignora todos os caracteres que não sejam espaços em branco. Aqui eu o converti para um formulário de fácil leitura. A primeira linha empurra 2a pilha e as duas segundas linhas imprimem a parte superior da pilha como um número aqui 2.
Observe que no código combinado, substituí as guias com quatro espaços devido a limitações técnicas.

3. Beatnik

K Jax
Jy Jy
My My
XO

Beatnik é um idioma em que cada palavra é convertida em sua pontuação do Scrabble; essas pontuações são interpretadas como comandos. A primeira linha entra 17na pilha. A segunda linha duplica o topo da pilha de duas vezes e a terceira linha adiciona o topo de elementos da pilha em conjunto duas vezes, triplicando eficazmente 17em 51. A última linha imprime o caractere no topo da pilha, aqui 3.
Observe que estou usando o Beatnik no Face Value, supondo que não haja um erro na especificação original do Beatnik. Observe também que estou usando o sistema de pontuação North American English Scrabble.

Se ainda não está claro, cada um desses idiomas aceita apenas um certo tipo de caractere (pontuação, espaço em branco e letras, respectivamente), portanto, escrever esse poliglota foi tão fácil quanto escrever os programas individuais. O único "truque" real é usar o código de espaço em branco para separar as palavras do Beatnik. Além disso, os programas individuais não se sobrepõem.

5 idiomas, 175/5 ^ 3 = 1,4

Decidi postar uma resposta diferente, pois a recompensa está mudando os requisitos de uma maneira que me fez sentir insegura com a minha primeira resposta (mas que ainda está me satisfazendo no caminho do grande desafio!)

Então, aqui está a minha solução que se qualifica para o desafio da recompensa:

Compila em

• C99
• objC90
• C ++ 0x
• Rubi
• Perl

#if __cplusplus
#define x\
=begin\
=pod
#endif
int a=
#ifndef x
1//**/
+1
#else
3
#endif
;int main(){printf("%d",a);}
#ifdef f
=end
puts 5;
=begin
=cut
print"4";
=end
#endif

3 idiomas, 15 bytes, pontuação 0,555 ...

Vou adicionar mais idiomas mais tarde.

2//1+1#😅😨

1. Emotinomicon

Emotinomicon praticamente ignora qualquer texto que não seja uma string. 😅pressiona 1 para empilhar e 😨envia os TOS como um número.

2. Javascript

Os comentários em Javascript começam com //, portanto, apenas a 2parte é executada.

3. Python 2/3 REPL

Os comentários no Python começam com #, portanto, apenas a 2//1+1parte é executada. //é uma divisão inteira no Python 3 e é igual /ao Python 2. 2 dividido por 1 é 2, mais 1 é 3.

4 idiomas, 97 bytes, 0,37890625

s="1";s=~-3;2//2;'''/.to_s.ord;"=;print 4;
__DATA__
=1;
";#'''#";print=s=>console.log(3)
print(s)

Rubi

Isso define sa "1", compara usando =~contra -3em um contexto vazio, tenta dividir 2pelo /2;'''/.to_s.ordentão começa uma nova string contendo =;print 4; __DATA__ =1;, atinge um comentário, em seguida, prints sque ainda é 1.

Pitão

Conjuntos spara "1"conforme acima, em seguida, define-o novamente para ~-3o que é 2. Nós executamos uma divisão inteira de 2//2, então há uma string contendo /.to_s.ord;"=;print 4; __DATA__ =1; ";#, seguida por um comentário, finalmente printing s, que ainda é 2.

Javascript

Define spara, em "1"seguida, define novamente ~-3como conforme descrito acima, e há 2uma linha seguida por um comentário. Em seguida, definimos a variável __DATA__como 1. Há uma sequência curta contendo, ;#'''#seguida por uma definição da função printque codifica a saída como 3, chamada na próxima linha.

Perl

Executa uma substituição equivalente a s/"1";s/~-3;2\/\/2;'''\/.to_s.ord;"/, prints 4e o restante da cadeia é mascarado por trás do __DATA__identificador.

QBasic, QBIC e> <>, 18 bytes / 3 ^ 3 idiomas = 0,66666 pontos

1:?v+1'-5`
''`>3n;

Demolir:

1. QBasic ( obtenha o IDE )

1:          Line number 1
  ?         Print
   v+1      undefined var v = 0 + 1 = 1
'-5`        The rest of theis code is a QBasic comment
''`>3n;     As is this

2. QBIC ( Pegue o intérprete )

1     inserts a 1 in the code - mostly harmless
:     Reads from the cmd line. Nothing there, creates an empty variable a
?     Print
v+1   v is initialised to 6, +1 = 7
'     Code Literal: everything till the ` is passed to QBasic without processing
 -5`  7-5 = 2

''`>3n; Code literal with the first literal being a ': comment in QBasic

3.> <> ( Experimente online )

1:  Push a 1 on the stack, duplicate stack
?   Pop top off the stack and skip next instruction if that's a 0
v   Move downwards - rest of the line is ignored

>   move to the right
3   Push 3 onto the stack
n   Print the top of the stack as a number
;   End the program

JavaScript, HTML e PHP, 72 bytes / 3 ^ 3 = 2,67

1<!top?2:2//><!--<?='--'.'><script>document.body.innerHTML=3</script>'?>

Em HTML, isso imprimirá o primeiro 1, ignorará a <!window?2:2//>tag e o restante será um comentário em HTML.

Em JavaScript, ele avalia 1<!window?2:2 e gera 2 (isso deve ser executado em um console) e o restante é um comentário.

No PHP, o seguinte é gerado pelo servidor: 1<!top?2:2//><!----><script>document.body.innerHTML=3</script>que substitui o HTML 1por 3.