El día de acción de gracias en los Estados Unidos se acerca el 24 de noviembre. Muchas personas tendrán una gran cena con sus familias, tradicionalmente incluyendo pavo y muchos platos de acompañamiento. Esto generalmente significa que los miembros de la familia deben coordinar quién traerá cada uno de los diversos platos. En este desafío, el objetivo es escribir un políglota que genere un plato diferente en cada idioma en el que se ejecuta.

Menú

(Seleccionado de Wikipedia . En caso de que no sea obvio, cada línea es un elemento).

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

Reglas

• Cada envío debe ejecutarse en al menos 3 idiomas , cada uno de los cuales debe mostrar un elemento diferente del menú. No puede usar varias versiones del mismo idioma (por ejemplo, Python 2 y Python 3 no se pueden usar en la misma respuesta).
• Cada entrada debe tener los mismos bytes en la codificación de cada idioma. Por ejemplo, ɱes byte 0x1Den la codificación de la jalea , que corresponde a ¢en la codificación del 05AB1E .
• Los diferentes idiomas pueden usar diferentes métodos de salida, pero las entradas deben ser programas completos en todos los idiomas y seguir uno de nuestros métodos de E / S permitidos por defecto .
• Ningún programa puede recibir información, pero cualquiera de los programas puede imprimir en STDERR o generar errores y advertencias de tiempo de ejecución / tiempo de compilación siempre que la salida correcta todavía se imprima en STDOUT o en un archivo.
• El caso y el espacio en blanco no importan. Por ejemplo, una salida de GreenbeAN Stodavía contaría como green beans.
• Como el plato central de cada ¹ comida de Acción de Gracias estadounidense es el pavo, debe emitirse un idiomaturkey (ignorando mayúsculas y minúsculas).

Tanteo

El envío que produce salidas válidas únicas en la mayoría de los idiomas gana. En caso de empate, gana la más corta de las entradas atadas en bytes.

^{1. Sí, el pavo no es el único plato principal , pero vamos a pretender que lo es.}

Pyke, Pyth, Python 2, Foo, Brain ****, GolfScript, En realidad, <> <, Gol <> <, En serio, Befunge, Fission, Haystack, 13 idiomas, 546 bytes

Cuando vi la otra respuesta de idioma 10 11 12 , tuve que agregar uno dos dos 3. También estoy considerando seriamente dejar caer Pyth aunque solo sea para ahorrar en bytes. (por el momento 162 de ellos)

#\ 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: ¡ Pruébalo aquí! rolls

Línea 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

Pyth: ¡ Pruébalo aquí! gravy

Línea 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 los )'s son para que Pyth lo haga compilar sin errores en ninguna entrada.

Python 2: corn

La línea 1 es un comentario completo

La línea 2 imprime "maíz" y luego tiene un comentario

La línea 3 tiene un literal de cadena y luego un comentario

La línea 4 en adelante son comentarios

Foo: ¡ Pruébalo en línea! biscuits

Foo imprime cualquier cosa entre comillas dobles ( "). En este caso, tuve cuidado de incluir solo idiomas que pudieran hacer frente a otras formas de entrada de cadena (Caso especial para Befunge). Si hubiera algún texto después de la final ", también se imprimiría.

Brain ****: ¡ Pruébalo en línea! salad

Copié la salida del generador de cadena constante. Tenía que escapar de todos los .personajes .qpara que jugara con Pyth y w.con Pyke. Agregué algunos -caracteres adicionales para que las celdas llegaran a los puntos correctos antes de imprimir en otro .personaje en la tercera línea

GolfScript: ¡ Pruébelo en línea! cornbread

En GolfScript, #es un comentario hasta el final de la línea.

Lo que ve el intérprete de GolfScript:

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

En GolfScript, por cualquier motivo, printtoma una cadena y la imprime sin una nueva línea. Solo tener breades suficiente para imprimirlo también.

En realidad: ¡ Pruébelo en línea! macandcheese

Línea 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 + Pegar solo turkey

Gol <> <: ¡ Pruébelo en línea! stuffing

Como <> <excepto se `salta el primero 'y solo muestra suficientes caracteres para imprimirstuffing

En serio: ¡ Pruébelo en línea! macaroniandcheese

Línea 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: ¡ Pruébelo en línea! sweettea

Código que se mira

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

Fisión: ¡ Pruébelo en línea! dressing

Código examinado:

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

De los cuales se utilizan:

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

Pajar (2015) : PECANPIE(¡con nuevas líneas 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

De los cuales hacer 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

Construyo cada punto de código ASCII PECANPIE en mayúscula para las letras en mayúscula porque están todas por debajo de 100. Luego las imprimo todas como caracteres.

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

¡2 bytes guardados gracias a @DrMcMoylex!

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

Código original de 36 bytes:

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

Después del &y antes del dhay un <ESC>, que es 1 byte. Entonces, el código con los caracteres de ancho cero revelados se ve así:

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

CJam

( <ESC>no se muestra)

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

Pruébalo en línea! salidasturkey

05AB1E

( <ESC>no se muestra)

"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

Pruébalo en línea! salidas:corn

V

( <ESC>se muestra)

"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

Pruébalo en línea! genera una nueva línea seguida desalad

Inmersión

( <ESC>no se muestra)

"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

Salidas gravy

Nota: No puede ejecutar python3 dip.pyy luego escribir código para esto debido al literal de caracteres de Escape. Aparece como ^[, lo que hace que el intérprete Dip se confunda y cree que [es un comando, y resulta en un error.

La mejor manera de ejecutar esto es editar el archivo fuente, cambiar la última línea en dip.py

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

a

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

¡Asegúrese de incluir el carácter de escape literal! Ahora el código tal como está se pasa al intérprete para que pueda entenderlo ( "tiene que escapar \"así). Ahora, si lo ejecuta desde la línea de comandos, interpreta el código real y las salidas gravy.

MAT / Golfscript / 05AB1E / CJAM : 4 idiomas, 34 33 bytes

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

• En MATL esto da salida TURKEY .
• En Golfscript que da salida rolls .
• En 05AB1E que da salida corn .
• En Cjam que da salida 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 los elementos del menú:

• Salidas C turkey
• salidas sh gravy
• Python 3 salidas biscuits
• Nim salidas rolls
• Salidas de Julia salad
• Brainf ** k salidas corn

Agregó Julia gracias a @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 (la versión 2015) , GolfScript , BF, Fission , Minkolang 0.15 , En serio , Axo : 14 idiomas, 381 bytes

Esta es una respuesta colaborativa con BlueEyedBeast

Decidí hacer un enfoque 2D a esta pregunta ... Sí, ¡hay 7 esolangs 2D!

Me he inspirado para agregar idiomas adicionales mediante la respuesta de BlueEyedBeast (Foo, GolfScript)

<ESC>es el carácter 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

Pruébalo en línea! salidascorn

> <>

Los comandos se muestran en el orden en que aparecen

                                    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

Pruébalo en línea! (Copiar y pegar solamente) salidassweettea

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"

Pruébalo en línea! salidas applepie(puede tardar unos 20 segundos para que se ejecute)

Python 2

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

Pruébalo en línea! (Copiar y pegar solamente) salidasbiscuits

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

Pruébalo en línea! salidassalad

Gol> <>

Los comandos se muestran en el orden en que aparecen

                                    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

Pruébalo en línea! salidasturkey

Foo

Foo muestra cualquier cosa entre comillas dobles, es por eso que he tenido cuidado de no usar comillas dobles en los otros idiomas. Como "stuffing"está entre comillas dobles, se imprimirá.

Pruébalo en línea! salidas stuffingy luego tiene un error

Pajar (2015)

Esto utiliza el intérprete 2015 (no 2016) de Haystack ya que la versión más nueva no es válida. El intérprete para esto es haystack.pyy no haystack_new.py

Los comandos se muestran en el orden en que aparecen

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

R
O
L
L
S

y una nueva línea después de esta salida (¡oye, el espacio en blanco no importa!)

GolfScript

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

Pruébalo en línea! salidaspecanpie

BF

Usé https://copy.sh/brainfuck/text.html para convertir texto en BF. Aunque hay muchas ,declaraciones de entrada, el código BF se ejecuta independientemente de él.

Pruébalo en línea! salidasgravy

Fisión

Para que comience un programa de fisión, se debe generar un átomo. Vemos que esto sucede en la tercera línea:

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

Pruébalo en línea! salidascornbread

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

Pruébalo en línea! salidasapplecider

Seriamente

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

Pruébalo en línea! salidasdressing

Axo

(Los comandos se muestran en el orden en que se encuentran)

#>                                          blah blah
  !                                         rotate direction 90 degrees clockwise

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

Pruébalo en línea! salidaspumpkinpie

Pushy , Python y Brainfuck

Este es mi primer políglota, así que no te esfuerces demasiado ... Para aquellos que se quejan del conteo de bytes, son 77 bytes, pero eso solo es relevante para el desempate.

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

Pushy imprime 'Turquía' con una nueva línea principal (así como un mensaje 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 'salsa' , ya que la primera y la última línea se tratan como comentarios.

Brainfuck ignora todos los demás caracteres y, excepto los de la línea final, que crean e imprimen la palabra 'maíz' .

Pip , BF , oOo CODE , > <> , Befunge-93 ( implementación de Quirkster ), Ouroboros , /// : 7 idiomas, 175 bytes

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

Pipa

Pruébalo en línea

Un grupo de expresiones que se descartan silenciosamente (la mayoría de las cuales generan advertencias, si las advertencias están habilitadas), con la expresión "sTufFINg"al final que se imprime.

/ '/ / 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

Pruébalo en línea

Todo excepto los >-[--[<]>+>-]<.++++++++++++.+++.----.,,,,comentarios. Este código genera 99(el código de caracteres para c) a través del método más corta que aparece en esolangs.org , a continuación, lo modifica para o, ry n. Los ,,,,intentos de entrada a cuatro personajes, pero que no afecta a nada.

oOo CODE

Todo, excepto las letras, se ignora. Agrupando las letras en tres, los códigos se leen así:

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

y se traduce a este código BF ( pruébelo usando el traductor de Martin Retina ):

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

que salidasrolls . (Y, curiosamente, es más corto que el BF anterior para la producción corn, incluso con un ><no-op agregado para que la capitalización se alinee correctamente).

> <>

Ejecute> <> código aquí

La parte importante del código:

/
        /ooooo;
>"YVaRg"^

La IP se refleja hacia arriba, se envuelve y se envía hacia la derecha. "YVaRg"empuja los códigos de caracteres de gRaVY. ooooosaca cinco letras y ;termina el programa.

Befunge-93

El código depende de un comportamiento indefinido y probablemente solo funcione en esta implementación .

La parte importante del código:

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

/es división La pila está vacía, por lo que la implementación de JavaScript que estoy usando se divide0 por 0y empujones NaN.

'Es un personaje no reconocido. La implementación que estoy usando, convenientemente, trata los caracteres no reconocidos como comandos Reflect. (Para una versión menos dependiente de la implementación, un posible reemplazo sería 1_). Entonces, la IP vuelve a la izquierda, se divideNaN por 0(obtener NaN) y se ajusta al otro extremo de la línea.

Ahora "yekRut"(mover RTL) empuja los códigos de caracteres de tuRkeyy,,,,,, genera. Finalmente, @termina el programa.

Ouroboros

Pruébalo aquí

Cada línea del código es una "serpiente" que se ejecuta de forma independiente.

Serpiente 1

Como no hay instrucciones de salida, la única parte importante del código es f(: fempuja 15y (traga tantos caracteres del final de la serpiente. Ahora se considera que el código termina después .O. La ejecución continúa hasta el final de la serpiente y vuelve al principio. Cada vez que pasa, la serpiente se acorta, hasta que finalmente se la (traga. Como la IP se acaba de comer, la serpiente detiene la ejecución.

Serpiente 2

"saLaD"empuja sus códigos de caracteres de último a primero; 1/divide el código de char rpor 1, dejándolo sin cambios y ooooogenera cinco caracteres. ;suelta un elemento (no operativo porque la pila ya está vacía). 1(se traga el puntero de instrucciones y se detiene.

Serpiente 3

"YVaRg"empuja algunos charcodes; luego se (traga un número de caracteres igual a la parte superior de la pila, que es 89el código de caracteres de Y. Comer 89 caracteres es suficiente para tragarse la IP y detener la ejecución.

///

Pruébelo en línea usando mi implementación Pip de ///

/'//elimina todas las comillas simples del resto del programa (que no hace nada porque no hay ninguna). A continuación, las bisCuItSsalidas como están. Finalmente, el resto del código es una sustitución incompleta, solo hay dos de las tres barras requeridas, por lo que no hace nada.

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

Mi segundo políglota, no muy golfizado, pero funciona:

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

_{(tenga en cuenta que ␛representa el byte de escape literal x1B)}

• Impresiones Cubix corn
• Impresiones agresivas turkey
• Impresiones Brainfuck ROLLS
• Impresiones en V gravy
• Impresiones de Python salad

Cubix

¡Prueba el programa en línea!

Cubix es un lenguaje del autor del desafío, ETHproductions. El intérprete de Cubix lee el código así:

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

El código se ejecuta así:

• 'salad - realiza algunas operaciones XOR irrelevantes en la pila, da como resultado 115, 0, 0
• '#; - empuje el código de char de # , luego (sin )
• "nroc" - empujar los códigos de barras para "maíz"
• w - mueve la IP al bucle en la siguiente línea a continuación:
  • !@o; - imprimir y reventar el último elemento (terminar si el elemento es 0)
  • "-[--";;;; - empuje estos caracteres y elimínelos (sin operación)
  • {{ - no-op

Molesto

¡Prueba el programa en línea!

Pushy es mi propio idioma y ejecuta el código de esta manera:

"          \ 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

¡Prueba el programa en línea!

Brainfuck ignora todos los caracteres que no están en su lista de instrucciones, lo que resulta en:

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

Que impresiones ROLLS. Tenga en cuenta que esto requiere un intérprete con celdas de ajuste, como el que se proporciona.

V (lenguaje Vim)

¡Prueba el programa en línea!

V fue creado por DJMcMayhem, uno de nuestros mejores golfistas de código.

V es una versión basada en programas del editor de texto Vim. La mayoría de los caracteres anteriores ESCse escriben en el "archivo", pero ␛ddgigravyeliminan todo eso e insertan "salsa" en su lugar. Se imprime el contenido del archivo al final del programa.

Python 2

¡Prueba el programa en línea!

Python es uno de mis lenguajes prácticos favoritos. Debido a que #es un comentario en Python, se ignora la mayor parte del programa. El código se lee así:

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

Python / QBasic / Pip , 3 idiomas, 41 bytes

Más idiomas posiblemente TBA.

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

Pitón

1es solo una expresión que se descarta. #comienza un comentario print("turkey")hace lo que dice, y "salad"es otra expresión que se descarta.

QBasic

1#es un número de línea (doble precisión). print"corn"hace lo que diceendtermina el programa La segunda línea es sintácticamente válida pero nunca se ejecuta.

Pipa

Casi todo son expresiones que se descartan. "corn":eintenta asignar a una cadena literal, que falla en silencio (a menos que las advertencias estén habilitadas). "salad"es la última expresión en el programa y, por lo tanto, se imprime.

PHP, JavaScript y BrainF * ck, 178 Bytes

La primera vez que probé un Polyglot, no voy a mentir, estoy loco por aquí ...

Golfizado:

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

(No me atreví a escribir una comida de Acción de Gracias en el código HTML y contarlo como otro idioma ...)

Explicación:

El código debe guardarse en un archivo .php para las partes PHP y JavaScript.

PHP:

Cuando se ejecuta en un servidor PHP, se lee la parte PHP del código:

<?php echo "turkey";?>

Esto produce:

JavaScript:

Puede llamar a la A()función JavaScript desde la consola del navegador:

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

Esto produce:

Brainf * cK

La parte de Brainf * ck está muy bien escondida en los comentarios en la sección de JavaScript, por lo que las partes de PHP y JavaScript la ignoran:

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

Cuando todo el archivo se pega en un IDE , esto genera:

No podría haber hecho la parte Brainf * ck sin este sitio web de texto a BF. Originalmente lo conseguí para generar código para "maíz" y luego, en un intento de aprender algo sobre este lenguaje loco, lo convertí a "salsa" ... o más bien "gravy" ...

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

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

Gracias a @ Sp3000 por la mayor parte del código. Sorprendentemente, ni siquiera tuve que hacerle nada a su original, solo tuve que anteponer el código Ruby.

///, SQL y JavaScript

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

La misma construcción que con ese otro políglota orientado a las vacaciones:

///

/*//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 / Common Lisp / PicoLisp, 39 bytes

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

Lisp familia aquí. '()se evalúa como verdadero en Clojure para que proceda a generar un símbolo turkey. PicoLisp y Common Lisp entra en una rama falsa; ""es verdadero en Common Lisp y, por lo tanto, imprime el símbolo rolls, la cadena vacía es falsa en PicoLisp y pasa al cornsímbolo de impresión .

Compruébalo en línea:

https://ideone.com/OD65LB - Clojure

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

https://ideone.com/B4x3ns - PicoLisp

CJam, Subcarga,> <>, 39 bytes

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

Lo que ve CJam

• 'v;: Un carácter literal que se descarta inmediatamente
• "(Turkey)S";: Un literal de cadena que se descarta inmediatamente
• "Gravy": Empuja la cadena Gravya la pila
• "\n'nroC'oooo;";: Literal de cadena que se descarta inmediatamente.

Al final de la ejecución, se genera la pila, lo que significa que se imprime "Gravy".

Qué subcarga ve

• 'v;": Algunos comandos no válidos que se ignoran
• (Turkey)S: Empuja la cadena "Turquía" y la emite
• ";"Gr: Algunos comandos no válidos que se ignoran
• a: Esto causa una falla predeterminada en el intérprete TIO ya que la pila está vacía. La ejecución finaliza.

Lo que> <> ve

• 'v;"(Turkey)S";"Gravy""empuja un montón de caracteres a la pila (que se ignoran). La IP luego se envuelve nuevamente.
• v envía la IP hacia abajo.
• >'nroC'oooo empuja los caracteres en la cadena "Corn" y los saca.
• ;termina la ejecución. Todos los demás personajes son ignorados.