O Dia de Ação de Graças nos Estados Unidos está chegando no dia 24 de novembro. Muitas pessoas terão um grande jantar com suas famílias, incluindo tradicionalmente a Turquia e muitos acompanhamentos. Isso normalmente significa que os membros da família devem coordenar quem vai levar cada um dos vários pratos. Neste desafio, o objetivo é escrever um poliglota que produza um prato diferente em cada idioma em que é executado.

Cardápio

(Selecionado da Wikipedia . Caso não seja óbvio, cada linha é um item.)

turkey
stuffing
dressing
cranberry sauce
mashed potatoes
gravy
winter squash
sweet potatoes
corn
green beans
green bean casserole
mac and cheese
macaroni and cheese
salad
rolls
biscuits
corn bread
pumpkin pie
apple pie
mincemeat pie
sweet potato pie
pecan pie
apple cider
sweet tea

Regras

• Cada envio deve ser executado em pelo menos três idiomas , cada um dos quais deve gerar um item diferente no menu. Você não pode usar várias versões da mesma linguagem (por exemplo, Python 2 e Python 3 não podem ser usados ​​na mesma resposta).
• Cada entrada deve ter os mesmos bytes na codificação de cada idioma. Por exemplo, ɱé byte 0x1Dna codificação de Jelly , o que corresponde a ¢na codificação de 05AB1E .
• Idiomas diferentes podem usar métodos de saída diferentes, mas as entradas devem ser programas completos em todos os idiomas e seguir um dos nossos métodos de E / S permitidos padrão .
• Nenhum programa pode receber entrada, mas qualquer um dos programas pode imprimir em STDERR ou emitir erros e avisos em tempo de execução / compilação, desde que a saída correta ainda seja impressa em STDOUT ou em um arquivo.
• Caixa e espaço em branco não importam. Por exemplo, uma saída de GreenbeAN Sainda contaria como green beans.
• Como o prato central de cada ^uma refeição americano de Ação de Graças é o peru, uma saída de linguagem deveturkey (ignorando caso e espaços em branco).

Pontuação

A submissão que produz saídas válidas exclusivas na maioria dos idiomas vence. Em caso de empate, a menor das entradas empatadas em bytes vence.

^{1. Sim, a Turquia não é o único prato principal , mas vamos fingir que é.}

Pyke, Pyth, Python 2, Foo, Brain ****, GolfScript, Na verdade, <> <, Gol <> <, Sério, Befunge, Fissão, Haystack, 13 idiomas, 546 bytes

Quando eu vi o outro 10 11 resposta linguagem 12 , eu tive que adicionar um extra de um dois 3. Eu também estou considerando seriamente a cair Pyth se apenas para economizar em bytes. (no momento 162 deles)

#\ s[\g\r\a\v\y)w.q)\r\o\l\l\ssp00/;oooooooo'stuffing;oooooo~'`turkey'
print'corn'#))))))))))))))))))))))))]+[--------->++<]>+w.q++[->+++<]>++w.q+++++++++++w.q-----------w.q----------------;))!+f'!n'!i'!s'!s'!e'!r'!d'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))L
'bread'#)))\é'i'n'o'r'a+++++))))))))))))))))))))))))))))))))))))))))))))))))\♀1X'c'a'm++++'e's'e'e'h'c'd'n'a++++++++)+.&\�0\ó))))))))))))))))))
#\25*8*0+c25*6*9+c25*6*7+c25*6*5+c25*7*8+c25*8*0+c25*7*3+c25*6*9+c|000000
# ,,,,,,,,@0>00000000\#"biscuits"aetteews"

Pyke: Experimente aqui! rolls

Linha de código relevante:

#s[\g\r\a  \v\y)w.q)\r\o\l\l\ssp00/;oooooooo'stuffing;oooooo~'`turkey'

#s[\g\r\a  \v\y)w.q) - effectively a comment because # doesn't do anything with an empty stack
\r\o\l\l\ss - sum("r", "o", "l", "l", "s")
p - print(^)
00/ - raise a ZeroDivisionError to stop running code

Pitão: Experimente aqui! gravy

Linha de código relevante:

#s[\g\r\a  \v\y)w.q)\r\o\l\l\ssp00/;oooooooo'stuffing;oooooo~'`turkey'

#...) - while True:
s[\g\r\a  \v\y) - sum(["g", "r", "a", "v", "y"])
w - input()
.q - quit

Todos )são para Pyth fazê-lo compilar sem erro em nenhuma entrada.

Python 2: corn

A linha 1 é um comentário completo

A linha 2 imprime "milho" e depois tem um comentário

A linha 3 tem uma string literal e, em seguida, um comentário

A linha 4 em diante são comentários

Foo: Experimente Online! biscuits

O Foo imprime qualquer coisa entre aspas duplas ( "). Nesse caso, tomei o cuidado de incluir apenas idiomas que pudessem lidar com outras formas de entrada de string (caso especial para Befunge). Se houvesse algum texto após a final ", isso também seria impresso.

Cérebro ****: Experimente Online! salad

Copiei a saída do gerador de string constante. Eu tive que fugir de todos os .personagens .qpara jogar com Pyth e w.jogar com Pyke. Adicionei alguns -caracteres extras para que as células chegassem aos pontos certos antes de imprimir em outro .caractere na terceira linha

GolfScript: Experimente Online! cornbread

No GolfScript, #é um comentário até o final da linha.

O que o intérprete GolfScript vê:

#comment
print'corn'#comment
'bread'#comment

No GolfScript, por qualquer motivo, printpega uma string e a imprime sem uma nova linha. Basta ter o breadsuficiente para imprimi-lo também.

Na verdade: Experimente Online! macandcheese

Linha relevante:

'bread'#)))\é'i'n'o'r'a+++++))))))))))))))))))))))))))))))))))))))))))))))))\♀1X'c'a'm++++'e's'e'e'h'c'd'n'a++++++++)+.&\�0\ó))))))))))))))))))

é - clears the stack of whatever junk was on it before.
'i'n'o'r'a+++++ - create string "aroni"
) - rotate entire stack (effectively comments as stack is only 1 long)
♀1X - pop stack (now empty)
'c'a'm++++ - constructs the string "mac"
'e's'e'e'h'c'd'n'a++++++++ - constructs the string "andcheese"
) - rotate stack (reverse)
+ - "mac" + "andcheese"
� - quit

<> <: Copiar + Colar apenas turkey

Gol <> <: Experimente Online! stuffing

Como <> <exceto `pula o primeiro 'e gera apenas caracteres suficientes para imprimirstuffing

Sério: Try It Online! macaroniandcheese

Linha relevante:

'bread'#)))\é'i'n'o'r'a+++++))))))))))))))))))))))))))))))))))))))))))))))))\♀1X'c'a'm++++'e's'e'e'h'c'd'n'a++++++++)+.&\�0\ó))))))))))))))))))
é - clears the stack of whatever junk was on it before.
'i'n'o'r'a+++++ - create string "aroni"
) - rotate entire stack (effectively comments as stack is only 1 long)
♀1X - no-op
'c'a'm++++ - constructs the string "mac" + "aroni"
'e's'e'e'h'c'd'n'a++++++++ - constructs the string "andcheese"
) - rotate stack (reverse)
+ - "macaroni" + "andcheese"
. - print stack
0\ó - exit

Befunge: Experimente Online! sweettea

Código que é analisado

#s[\g\r\a  \v - |
            ) - | - Directing the stack pointer to the correct place
            é - |
# ,,,,,,,,@0>00000000\#"biscuits"aetteews"

            >                              - change direction of travel
             00000000\#"biscuits           - a load of no-ops `#` skips the opening `"`
                                "aetteews" - add the chars to the stack in reverse order
  ,,,,,,,,@                                - output 8 chars from the stack and exit.

Fissão: Experimente Online! dressing

O código olhou para:

;))!+f'!n'!i'!s'!s'!e'!r'!d'))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))L

Dos quais são utilizados:

;!+f'!n'!i'!s'!s'!e'!r'!d'L
                          L - start an atom going left
                      !d'   - create the character `d` and print it
                              ...
;                           - exit

Palheiro (2015) : PECANPIE(com novas linhas EXTRA!)

#\
 r
 b
 \25*8*0+c25*6*9+c25*6*7+c25*6*5+c25*7*8+c25*8*0+c25*7*3+c25*6*9+c

Dos quais algo funcional:

  25*8*0+c25*6*9+c25*6*7+c25*6*5+c25*7*8+c25*8*0+c25*7*3+c25*6*9+c

Construo cada ponto de código ASCII maiúsculo para as letras em PECANPIE maiúsculas, porque elas estão abaixo de 100. Em seguida, imprimo todas como caracteres.

CJam , 05AB1E , Dip , V , 4 idiomas, 36 34 bytes

2 bytes salvos graças a @DrMcMoylex!

"turkey"e#"corn"??"gravy"p&Ssalad

Código original de 36 bytes:

"turkey"e#"corn"??"gravy"p&ddisalad

Após &e antes do, dexiste um <ESC>, que é de 1 byte. Portanto, o código com os caracteres de largura zero revelados se parece com o seguinte:

"turkey"e#"corn"??"gravy"p&Ssalad

CJam

( <ESC>não é mostrado)

"turkey"e#"corn"??"gravy"p&Ssalad
"turkey"                           e# push this string
        e#"corn"??"gravy"p&Ssalad  e# comment
                                   e# implicit output

Experimente online! saídasturkey

05AB1E

( <ESC>não é mostrado)

"turkey"e#"corn"??"gravy"p&Ssalad
"turkey"                           # push this string
                                   # STACK: ["turkey"]
        e                          # calculates nPr for the last two values in the stack
                                   # since there is only one value, this evaluates to nothing
                                   # as a result, "turkey" is popped
                                   # STACK: []
         #                         # if true end, since this is false, the program doesn't end
          "corn"?                  # push this string and print it without newlines
                                   # STACK: []
                 ?                 # prints nothing, since there is nothing in stack
                  "gravy"p&Ssalad  # nothing happens here since the stack is already printed using a command and there is NO implicit print now, I think

Experimente online! saídas:corn

V

( <ESC>é mostrado)

"turkey"e#"corn"??"gravy"p&<ESC>Ssalad
"turkey"e#"corn"??"gravy"p&             Code that writes a newline followed by `rn"??"gravy"p&Ssalad`
                           <ESC>        Enters normal mode
                                S       Deletes line and enters insert mode
                                 salad  Writes salad

Experimente online! gera uma nova linha seguida porsalad

Mergulho

( <ESC>não é mostrado)

"turkey"e#"corn"??"gravy"p&Ssalad
"turkey"                           push this string
                                   STACK: ["turkey"]
        e                          not in the language's database
         #                         push str("turkey") --> "turkey"
                                   STACK: ["turkey"]
          "corn"                   push this string
                                   STACK: ["turkey","corn"]
                ?                  pop "corn", if it is the boolean True (which it isn't) execute the following,
                                   but since it is false, nothing until the next ? gets executed
                                   STACK: ["turkey"]
                 ?                 if-statement end
                                   STACK: ["turkey"]
                  "gravy"          push this string
                                   STACK: ["turkey","gravy"]
                         p&        print turkey and end program
                           Ssalad  irrelevant since program has ended

Saídas gravy

Nota: Você não pode executar python3 dip.pye digitar o código para isso devido ao literal de caractere Escape. Aparece como ^[, o que faz com que o intérprete Dip fique confuso e pensa que [é um comando e resulta em um erro.

A melhor maneira de executar isso é editar o arquivo de origem, alterar a última linha em dip.py

main(input(">>> "), stack.Stack())

para

main("\"turkey\"e#\"corn\"??\"gravy\"p&Ssalad", stack.Stack())
exit()

Certifique-se de incluir o caractere de escape literal !. Agora, o código tal como está é passado para o intérprete, para que ele possa entendê-lo ( "precisa ser escapado \"dessa maneira). Agora, se você executá-lo na linha de comando, ele interpreta o código e as saídas reais gravy.

MATL / Golfscript / 05AB1E / CJam : 4 idiomas, 34 33 bytes

'TURKEY'%"rolls"#];"corn""bread"s

• Em MATL isso gera TURKEY .
• No Golfscript, ele gera rolls .
• Em 05AB1E, ele gera corn .
• No CJam, ele gera cornbread .

C, sh, Python 3, Nim, Julia, Brainf ** k - 6 idiomas, 211 209 bytes

#define println(x) main(){puts("turkey");}/*
#[
#=
a=''''
echo gravy
'''
println=lambda x:print("biscuits")
# ]#proc println[T](s:T)=echo"rolls"#--[----->+<]>---.++++++++++++.+++.----.
# =##*/
println("salad")

Idiomas para itens de menu:

• Saídas C turkey
• saídas sh gravy
• Saídas Python 3 biscuits
• Saídas Nim rolls
• Julia produz salad
• Saídas Brainf ** k corn

Adicionado Julia thanks para @kvill!

ferNANDo /> <> / Gol> <> / 05AB1E / 2sable, 5 idiomas, 178 bytes

!v"`"v"!
     <;ooooo"salad"
"<;oooooooo"dressing
1 0
0 1 1 1 0 1 0 0
0 1 1 1 0 1 0 1
0 1 1 1 0 0 1 0
0 1 1 0 1 0 1 1
0 1 1 0 0 1 0 1
0 1 1 1 1 0 0 1
")\"corn""ab"û"aba"Qi"rolls"

• ferNANDo :turkey
• > <> :salad
• Gol> <> :dressing
• 05AB1E :rolls
• 2sable :corn

Befunge-98 , > <> , V , Python 2, 05AB1E , Gol> <> , Foo , Haystack (versão de 2015) , GolfScript , BF, Fission , Minkolang 0,15 , sério , Axo : 14 idiomas, 381 bytes

Esta é uma resposta colaborativa com BlueEyedBeast

Eu decidi fazer uma abordagem 2D para esta pergunta ... Sim, existem 7 esolangs 2D!

Eu me inspirei em outros idiomas a serem adicionados pela resposta de BlueEyedBeast (Foo, GolfScript)

<ESC>é o caractere literal de Escape .

#>!>\'n\'r\'o\'c\,,,,,@'s'a'l'a'dJ,é'g'n+'i+'s+'s+'e+'r+'d+.ó[-]+[----->+++<]>.+++++++++++.+++[->+++<]>++.+[--->+<]>.+++H'turkey'~;oooooooo'sweettea.0-5++++++++fffffffff''`'
#   >99*d1+c3-c89*4+dcc99*2+c!|$l9D3-O93++dOO8+O1+O1-O5+OO1+O95++O.
# >'p'()'u'()'m'()'p'()'k'()'i'()'n'()'p'()'i'()'e'()\
print'biscuits';'pecanpie'#"stuffing"R'c!'o!'r!'n!'b!'r!'e!'a!'d!*<ESC>ddddddSapplepie

Befunge-98

#?!>                                nothing important
  'n                                push 'n'
                                    STACK: [110]
    \                               swap top two stack values (TBH, I'm not really sure what happens in this case)
                                    STACK: [110, 0]
     'r\'o\'c\                      repeat the same for other characters
                                    STACK: [110 114 111 99 0]
              ,,,,,                 output the next 5 top stack values, "corn"
                   @                end program
                                    rest of the code is irrelevant
                                    since program has already stopped

Experimente online! saídascorn

> <>

Os comandos são mostrados na ordem em que aparecem

                                    enter from the left, direction = right
#                                   mirror, now the direction will change to left
                                    and it wraps around and comes to the right
                                    and reads code from the right to the left
'`'                                 push this
   ' ... 5-0.aetteews'              push this too
                      oooooooo      outputs the top 5 characters of the stack
                              ;     end program

Experimente online! (Apenas copiar e colar)sweettea

V

             ...<ESC>                 writes stuff over three lines and enters normal mode
                     ddddddS          deletes 3 lines, delete another line and enter insert mode
                            applepie  writes "applepie"

Experimente online! saídas applepie(pode demorar 20 segundos para ser executado)

Python 2

                                    # first two lines are comments
print"biscuits";                    # prints "biscuits" and ends statement
                'pecanpie'          # dangling (and ignored) string literal 

Experimente online! (Apenas copiar e colar)biscuits

05AB1E

#>!>                                # does nothing important
\'n\                                # push 'n' and delete it
     'r\'o\'c\                      # repeat for other characters
              ,,,,,                 # prints 5 times (since there is nothing in stack,
                                    #                 prints nothing)
                   @                # push the index of the top of stack
                    's'a'l'a'd      # push these characters
                              J,    # join them and print them out
                                    # the rest of the code does not matter
                                    # since there is no implicit print
                                    # because we used the print statement

Experimente online! saídassalad

Gol> <>

Os comandos são mostrados na ordem em que aparecem

                                    enter from the left, direction = right
#                                   mirror, now the direction changes to left
                                    and it wraps around and comes to the right
                                    and reads code from the right to the left
 '                                  starting parsing strings
  `                                 escape next character
   '                                gets escaped
    "                               stop string parsing
     fffffffff                      pushes 15, 8 times
           ++++++++                 adds up the numbers, resulting in 135
                 5-                 subtract 4 from it, 130
                   0                pushes 0
                    0               jumps to (130, 0)

#\'n\'r\'o\'c\,,,,,@'r'o'l'l'sJ, ... H'turkey'~;oooooooo"sweettea.0-5++++++++fffffffff""`"
                                              ^
                                       we are here now

                     ˜              removes value at top of stack, '"'
                      "yekrut"      push this string
                              H     Output stack as characters and halt program

Experimente online! saídasturkey

Foo

Foo produz qualquer coisa entre aspas duplas, é por isso que tomei o cuidado de não usar aspas duplas nos outros idiomas. Como "stuffing"está entre aspas duplas, ele será impresso.

Experimente online! saídas stuffinge, em seguida, tem um erro

Palheiro (2015)

Isso usa o intérprete de 2015 do Haystack (não 2016), pois a versão mais recente é inválida. O intérprete para isso é haystack.pye não haystack_new.py

Os comandos são mostrados na ordem em que aparecem

#                                 ignored
 \                                reflection (now it moves downwards)
  >                               set direction to right
   99*d1+c                        Output 'R'
          3-c                     Output 'O'
             89*4+dcc             Outputs 'L', newline, 'L'
                     99*2+c!|     Outputs 'S' and ends the program
                                  Note: '!' is ignored by the interpreter

Este programa gera

R
O
L
L
S

e uma nova linha após essa saída (ei, espaço em branco não importa!)

GolfScript

                                    first 2 lines are comments
print'biscuits';                    pushes "biscuits" to the stack and discards it
                'pecanpie'          push this
                          #...      comment
                                    implicit output

Experimente online! saídaspecanpie

BF

Usei https://copy.sh/brainfuck/text.html para converter texto em BF. Embora existam muitas ,instruções de entrada, o código BF é executado independentemente.

Experimente online! saídasgravy

Fissão

Para que um programa de fissão comece, um átomo precisa ser gerado. Vemos isso acontecendo na terceira linha:

..."stuffing"                                Blah blah blah
             R                               Spawns an atom with direction right
              'c                             Gives the atom the mass of 'c''s ASCII value
                !                            Print the atom's mass
                 'o!'r!'n!'b!'r!'e!'a!'d!    Do the same for other characters
                                         *   Destroy atom, end program

Experimente online! saídascornbread

Minkolang v0.15

#                                Doesn't really do anything
 \                               Reflect, moves downwards
  >                              Changes direction to right
    ... !|                       Does stuff in stack, '!' ignores the '|'
          $l9D3 ... ++O          Uses ASCII character codes to print "applecider"
                       .         Ends program

Experimente online! saídasapplecider

A sério

é                          - clear stack
 'g'n+'i+'s+'s+'e+'r+'d+   - load chars onto stack
                        .  - print stack
                         ó - exit

Experimente online! saídasdressing

Axo

(Os comandos são mostrados na ordem em que são encontrados)

#>                                          blah blah
  !                                         rotate direction 90 degrees clockwise

  >                                         go right
   'p'()                                    push char and output
        'u'() ... 'e'()                     repeat for other characters
                       \                    end program

Experimente online! saídaspumpkinpie

Pushy , Python e Brainfuck

Este é o meu primeiro poliglota, portanto, não seja muito duro comigo ... Para aqueles que reclamam da contagem de bytes, são 77 bytes, mas isso é relevante apenas para o desempatador.

"`turkey`"
print('gravy')
#++++++++++[>++++++++++<-]>-.++++++++++++.+++.----.

Pushy imprime 'turkey' com uma nova linha de frente (assim como uma mensagem para STDERR):

"        % Print current stack: just a newline as stack is empty
`turkey` % Push to stack
"        % Print the stack: 'turkey'
p        % Primality check on 'y' (121): pushes 0
r        % Integer root of 0: throws error and exits

Python imprime 'molho' , pois a primeira e a última linha são tratadas como comentários.

Brainfuck ignora todos os outros caracteres, exceto os da linha final, que criam e imprimem a palavra 'milho' .

Pip , BF , oOo CODE , > <> , Befunge-93 ( implementação Quirkster ), Ouroboros , /// : 7 idiomas, 175 bytes

/'//bisCuItS/`f(>-[--[<]>+>-]<.++++++++++++.+++.----.O@,,,,,,"tuRkey"
"saLaD"1/ooooo;1(
>"YVaRg"^(OoooOoOOoooOoooOOoooOOoOooOooOooOOoOooOooOooOOoOOoOoOOoOOoOOoOOo`OO"sTUfFINg"

Pip

Experimente online

Um monte de expressões que são descartadas silenciosamente (a maioria gera avisos, se os avisos estiverem ativados), com a expressão "sTufFINg"no final impressa.

/ '/ / b      Invert the string "/" and divide it by nil
i s           Two different variables
Cu            Chr(nil)
It            If 10:
S / `...` OO   Invert a Pattern literal and swap it with undefined variable OO
"sTufFINg"    Autoprint this last expression

BF

Experimente online

Tudo, exceto >-[--[<]>+>-]<.++++++++++++.+++.----.,,,,comentários. Este código gera 99(o código de caracteres para c) através do método mais curta listada na esolangs.org , em seguida, modifica-o para o, re n. A ,,,,tentativa de inserir quatro caracteres, mas isso não afeta nada.

oOo CODE

Tudo, exceto as letras, é ignorado. Agrupando as letras em três, os códigos são assim:

bis CuI tSf Otu Rke ysa LaD ooo ooY VaR gOo ... OsT UfF INg

e traduz para este código BF ( tente usando o tradutor Martin's Retina ):

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

quais saídasrolls . (E, curiosamente, é menor que o BF acima para saída corn, mesmo com um ><no-op adicionado para fazer a capitalização alinhar corretamente.)

> <>

Execute o código> <> aqui

A parte importante do código:

/
        /ooooo;
>"YVaRg"^

O IP é refletido para cima, envolve e é enviado para a direita. "YVaRg"envia os códigos de caracteres de gRaVY. oooooproduz cinco letras e ;finaliza o programa.

Befunge-93

O código depende de um comportamento indefinido e provavelmente só funciona nesta implementação .

A parte importante do código:

/'                        @,,,,,,"tuRkey"

/é divisão. A pilha está vazia, então a implementação JavaScript que estou usando divide 0por 0e empurrões NaN.

'é um caractere não reconhecido. A implementação que estou usando, convenientemente, trata caracteres não reconhecidos como comandos Reflect. (Para uma versão menos dependente da implementação, uma possível substituição seria 1_.) Portanto, o IP fica novamente à esquerda, divide NaNpor 0(obtendo NaN) e passa para o outro extremo da linha.

Agora "yekRut"(mover RTL) pressiona os códigos de caracteres tuRkeye os ,,,,,,gera. Por fim, @finaliza o programa.

Ouroboros

Experimente aqui

Cada linha do código é uma "cobra" que é executada independentemente.

Cobra 1

Como não há instruções de saída, a única parte importante do código é f(: fempurra 15e (engula muitos caracteres do final da serpente. O código agora é considerado finalizado depois .O. A execução continua até o final da cobra e volta ao início. A cada vez, a cobra fica mais curta, até que (seja engolida. Desde que o IP acabou de ser comido, a cobra interrompe a execução.

Cobra 2

"saLaD"empurra seus códigos de caracteres do penúltimo para o primeiro; 1/divide o código de rpor 1, deixando-o inalterado e ooooogera cinco caracteres. ;descarta um item (no-op porque a pilha já está vazia). 1(engole o ponteiro da instrução e pára.

Cobra 3

"YVaRg"empurra alguns códigos; em seguida, (engole um número de caracteres igual ao topo da pilha, que passa a ser 89, o código de caracteres de Y. Comer 89 caracteres é suficiente para engolir o IP e interromper a execução.

///

Experimente on-line usando minha implementação Pip de ///

/'//exclui todas as aspas simples do restante do programa (o que não faz nada porque não há nenhuma). Em seguida, bisCuItSsai como está. Por fim, o restante do código é uma substituição incompleta - há apenas duas das três barras necessárias -, portanto, não faz nada.

Cubix, Pushy, Brainfuck, V, Python 2 - 5 idiomas, 89 85 bytes

Meu segundo poliglota - nunca muito jogado, mas funciona:

"`turkey`";print'salad'#;"nroc"w!@o;"-[--";;;;{{->+<]>---.---.---..+++++++.␛ddgigravy

_{(observe que ␛representa o byte de escape literal x1B)}

• Impressões Cubix corn
• Impressões insistentes turkey
• Impressões Brainfuck ROLLS
• Impressões V gravy
• Impressões em Python salad

Cubix

Teste o programa online!

Cubix é uma linguagem do autor do desafio, ETHproductions. O intérprete Cubix lê o código assim:

        " ` t u
        r k e y
        ` " ; p
        r i n t
' s a l a d ' # ; " n r o c " w
! @ o ; " - [ - - " ; ; ; ; { {
- > + < ] > - - - . - - - . - -
- . . + + + + + + + . d d g i ␛
        g r a v
        y . . .
        . . . .
        . . . .

O código é executado da seguinte maneira:

• 'salad - faz algumas operações XOR irrelevantes na pilha, resulta em 115, 0, 0
• '#;- pressione o código de e #, em seguida, digite -o novamente (sem operação )
• "nroc" - pressione os códigos para "milho"
• w - move o IP para fazer um loop na próxima linha abaixo:
  • !@o; - imprima e pop o último item (termine se o item for 0)
  • "-[--";;;; - pressione esses caracteres e exclua-os (no-op)
  • {{ - no-op

Pushy

Teste o programa online!

Pushy é minha própria linguagem e executa o código da seguinte maneira:

"          \ Print stack. Empty, so prints newline.
`turkey`   \ Push this string
"          \ Print this string
;          \ "End loop": Ignored as there is no loop in progress.
pr         \ Irrelevant stack operations
i          \ "interrupt": exit program.

Brainfuck

Teste o programa online!

O Brainfuck ignora todos os caracteres que não estão na sua lista de instruções, resultando em:

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

Que imprime ROLLS. Observe que isso requer um intérprete com células de quebra automática, como a fornecida.

V (idioma Vim)

Teste o programa online!

V foi criado por DJMcMayhem, um dos nossos principais jogadores de código.

V é uma versão baseada em programa do editor de texto Vim. A maioria dos caracteres antes do ESCtexto é gravada no "arquivo", mas ␛ddgigravyexclui tudo isso e insere "molho". O conteúdo do arquivo no final do programa é impresso.

Python 2

Teste o programa online!

Python é uma das minhas linguagens práticas favoritas. Por #ser um comentário em Python, a maior parte do programa é ignorada. O código é lido assim:

"`turkey`";            # Unused string literal
print'salad'           # Print statement
#...                   # Comment (everything else is ignored)

Python / QBasic / Pip , 3 idiomas, 41 bytes

Mais idiomas, possivelmente TBA.

1#print"corn":end
print("turkey");"salad"

Python

1é apenas uma expressão que é descartada. #inicia um comentário. print("turkey")faz o que diz e "salad"é outra expressão que é descartada.

QBasic

1#é um número de linha (precisão dupla). print"corn"faz o que diz. endfinaliza o programa. A segunda linha é sintaticamente válida, mas nunca executada.

Pip

Quase tudo são expressões que são descartadas. "corn":etenta atribuir a uma cadeia literal, que falha silenciosamente (a menos que os avisos estejam ativados). "salad"é a última expressão no programa e, portanto, é impressa.

PHP, JavaScript e BrainF * ck, 178 bytes

A primeira vez que experimentei um poliglota - não vou mentir, estou louca aqui ...

Golfe:

<!DOCTYPE html><html><body><?php echo "turkey";?></body><script>function A(){alert("stuffing");}//`--[----->+<]>-++.+++++++++++.-----------------.-----------.+++.`
</script></html>

(Não ousei escrever um alimento de Ação de Graças no código HTML e contar isso como outra linguagem ...)

Explicação:

O código precisa ser salvo em um arquivo .php para as partes PHP e JavaScript.

PHP:

Quando executada em um servidor PHP, a parte do código PHP é lida:

<?php echo "turkey";?>

Isso gera:

JavaScript:

Você pode chamar a A()função JavaScript no console do navegador:

function A(){alert("stuffing");}

Isso gera:

Brainf * cK

A parte Brainf * ck está bem oculta nos comentários na seção JavaScript, portanto é ignorada pelas partes PHP e JavaScript:

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

Quando o arquivo inteiro é colado em um IDE , isso gera:

Eu não poderia ter feito a parte Brainf * ck sem este site de texto para BF. Originalmente, consegui gerar código para "corn" e, em uma tentativa de aprender algo sobre essa linguagem maluca, converti-a em "molho" ... ou melhor, "graVY" ...

Python, Clojure, Javascript, Ruby: 4 idiomas, 113 bytes

1;''''/*
#_(
puts("turkey")
__END__
);'''
1;1//2;'''
1;*/alert("gravy")/*
(print "salad");'''
#_
print "corn";#*/

Obrigado a @ Sp3000 pela maior parte do código. Surpreendentemente, eu nem precisei fazer nada com o original, apenas precisei acrescentar o código Ruby.

///, SQL e JavaScript

/*//turkey/\*/select('corn')
--a;function select(){alert('salad')}

Mesma construção que a outra poliglota orientada para férias:

///

/*//turkey/../..   Simply prints 'turkey', does no replaces, stops execution because the second /// block is incomplete

SQL

/*//turkey/\*/    //turkey/\ is seen as a block comment
                  That last \ was added to set apart the following */, completing the block
select('corn')    SQL Select statement, yielding 'corn'
--a;...           Seen by SQL as a comment, ignored

Javascript

/*//turkey/\*/    //turkey/\ is seen as a block comment
select('corn')    Function call to the function 'select', defined below
--a;              Decrement a, effectively a NOP
function select(){alert('salad')}
                  Defines the function select(), giving us 'salad'

Clojure / Lisp comum / PicoLisp, 39 bytes

(print(if '()'turkey(if""'rolls'corn)))

Família Lisp aqui. '()é avaliada como verdadeira no Clojure, para que ele produza um símbolo turkey. PicoLisp e Common Lisp entram em ramificação falsa; ""é verdadeiro no Common Lisp e, portanto, imprime o símbolo rolls, a string vazia é falsa no PicoLisp e, portanto, passa para a impressão do cornsímbolo.

Verifique on-line:

https://ideone.com/OD65LB - Clojure

https://ideone.com/M1H5gf - Lisp comum

https://ideone.com/B4x3ns - PicoLisp

CJam, Subcarga,> <>, 39 bytes

'v;"(Turkey)S";"Gravy""
 >'nroC'oooo;";

O que o CJam vê

• 'v;: Um literal de caractere que é descartado imediatamente
• "(Turkey)S";: Uma literal de cadeia que é imediatamente descartada
• "Gravy": Empurra a string Gravypara a pilha
• "\n'nroC'oooo;";: Uma literal de cadeia que é imediatamente descartada.

No final da execução, a pilha é impressa, o que significa que "Molho" é impresso.

O que Underload vê

• 'v;": Alguns comandos inválidos que são ignorados
• (Turkey)S: Empurra a string "Turkey" e a produz
• ";"Gr: Alguns comandos inválidos que são ignorados
• a: Isso causa um segfault no interpretador TIO, pois a pilha está vazia. A execução é encerrada.

O que> <> vê

• 'v;"(Turkey)S";"Gravy""envia vários caracteres para a pilha (que são ignorados). O IP então volta.
• v envia o IP para baixo.
• >'nroC'oooo empurra os caracteres na string "Corn" e os produz.
• ;finaliza a execução. Todos os outros caracteres são ignorados.