Il Ringraziamento negli Stati Uniti è in arrivo il 24 novembre. Molte persone avranno una grande cena con le loro famiglie, tradizionalmente tra cui tacchino e molti contorni. Questo in genere significa che i membri della famiglia devono coordinare chi porterà ciascuno dei vari piatti. In questa sfida, l'obiettivo è quello di scrivere un poliglotta che produca un piatto diverso in ogni lingua in cui viene eseguito.

Menu

(Selezionato da Wikipedia . Nel caso in cui non sia ovvio, ogni riga è 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

Regole

• Ogni invio deve essere eseguito almeno 3 lingue , ognuna delle quali deve generare una voce diversa dal menu. Non è possibile utilizzare più versioni della stessa lingua (ad esempio Python 2 e Python 3 non possono essere utilizzati nella stessa risposta).
• Ogni voce deve avere gli stessi byte nella codifica di ogni lingua. Ad esempio, ɱè byte 0x1Din codifica di gelatina , che corrisponde ¢a codifica di 05AB1E .
• Lingue diverse possono utilizzare metodi di output diversi, ma voci devono essere programmi completi in tutte le lingue e seguire uno dei nostri metodi IO consentiti predefiniti .
• Nessun programma può ricevere input, ma nessuno dei programmi può stampare su STDERR o generare errori e avvisi in fase di runtime / compilazione fino a quando l'output corretto viene ancora stampato su STDOUT o su un file.
• Il caso e lo spazio bianco non contano.Ad esempio, un output di GreenbeAN Sconterebbe comunque come green beans.
• Poiché il piatto centrale di ogni ¹ pasto del Ringraziamento americano è il tacchino, deve essere prodotta una linguaturkey (ignorando il caso e gli spazi bianchi).

punteggio

Vince l'invio che produce output validi unici nella maggior parte delle lingue.In caso di pareggio, vince la più breve delle voci legate in byte.

^{1. Sì, il tacchino non è l'unico piatto principale , ma facciamo finta che lo sia.}

Pyke, Pyth, Python 2, Foo, Brain ****, GolfScript, In realtà, <> <, Gol <> <, Scherzi a parte, Befunge, Fission, Haystack, 13 lingue, 546 byte

Quando ho visto l'altro 10 11 12 risposta lingua , ho dovuto aggiungere un extra di uno due 3. Inoltre sto seriamente pensando di far cadere Pyth anche solo per risparmiare sui byte. (al momento 162 di essi)

#\ 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: provalo qui! rolls

Riga di codice pertinente:

#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: provalo qui! gravy

Riga di codice pertinente:

#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

Tutte le )'s sono per Pyth per farlo compilare senza erroring su nessun ingresso.

Python 2: corn

La riga 1 è un commento completo

La riga 2 stampa "mais" e quindi ha un commento

La riga 3 ha una stringa letterale e quindi un commento

La riga 4 in poi sono commenti

Foo: provalo online! biscuits

Foo stampa qualsiasi cosa racchiusa tra virgolette doppie ( "). In questo caso sono stato attento a includere solo le lingue che potevano far fronte ad altre forme di input di stringhe (caso speciale per Befunge). Se ci fosse del testo dopo la finale ", verrebbe stampato anche quello.

Cervello ****: provalo online! salad

Ho copiato l'output del generatore di stringhe costanti. Ho dovuto sfuggire a tutti i .personaggi .qper giocare con Pyth e w.giocare con Pyke. Ho aggiunto alcuni -caratteri extra in modo che le celle arrivassero ai punti giusti prima di stampare su un altro .personaggio nella terza riga

GolfScript: provalo online! cornbread

In GolfScript, #è un commento fino alla fine della riga.

Cosa vede l'interprete GolfScript:

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

In GolfScript, per qualsiasi motivo, printprende una stringa e la stampa senza una nuova riga. Basta avere anche breadper stamparlo.

In realtà: provalo online! macandcheese

Linea pertinente:

'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

<> <: Copia + Incolla solo turkey

Gol <> <: provalo online! stuffing

Come <> <tranne `salta il primo 'e genera solo caratteri sufficienti per la stampastuffing

Scherzi a parte: provalo online! macaroniandcheese

Linea pertinente:

'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: provalo online! sweettea

Codice che viene visualizzato

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

Fissione: provalo online! dressing

Il codice ha esaminato:

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

Di cui vengono utilizzati:

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

Haystack (2015) : PECANPIE(con le nuove linee 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

Di cui fare qualcosa di funzionale:

  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

Costruisco ogni punto di codice ASCII maiuscolo per le lettere in PECANPIE maiuscolo perché sono tutte inferiori a 100. Poi le stampo tutte come caratteri.

CJam , 05AB1E , Dip , V , 4 lingue, 36 34 byte

2 byte salvati grazie a @DrMcMoylex!

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

Codice originale 36 byte:

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

Dopo &e prima di dc'è un <ESC>, che è 1 byte. Quindi il codice con i caratteri di larghezza zero rivelati è simile al seguente:

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

CJam

( <ESC>non è mostrato)

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

Provalo online! usciteturkey

05AB1E

( <ESC>non è mostrato)

"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

Provalo online! uscite:corn

V

( <ESC>è mostrato)

"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

Provalo online! genera una nuova riga seguita dasalad

Tuffo

( <ESC>non è mostrato)

"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

Uscite gravy

Nota: non è possibile eseguire python3 dip.pye quindi digitare il codice per questo a causa del carattere Escape letterale. Sembra come ^[, il che fa confondere l'interprete Dip e pensa che [sia un comando, e si traduce in un errore.

Il modo migliore per eseguire questo è modificare il file sorgente, cambiare l'ultima riga in dip.py

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

a

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

Assicurati di includere il carattere di escape letterale !. Ora il codice così com'è viene passato all'interprete in modo che possa capirlo ( "deve essere evitato in questo \"modo). Ora, se lo esegui dalla riga di comando, interpreta il codice e gli output effettivi gravy.

MATL / Golfscript / 05AB1E / CJam : 4 lingue, 34 33 byte

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

• In MATL questo produce TURKEY .
• In Golfscript essa emette rolls .
• In 05AB1E essa emette corn .
• In CJam essa emette cornbread .

C, sh, Python 3, Nim, Julia, Brainf ** k - 6 lingue, 211 209 byte

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

Lingue per voci di menu:

• Uscite C. turkey
• uscite sh gravy
• Uscite Python 3 biscuits
• Uscite Nim rolls
• Uscite Julia salad
• Uscite Brainf ** k corn

Aggiunta Julia grazie a @kvill!

ferNANDo /> <> / Gol> <> / 05AB1E / 2sable, 5 lingue, 178 byte

!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
• 2 set :corn

Befunge-98 , > <> , V , Python 2, 05AB1E , Gol> <> , Foo , Haystack (versione 2015) , GolfScript , BF, Fission , Minkolang 0.15 , Scherzi a parte , Axo : 14 lingue, 381 byte

Questa è una risposta collaborativa con BlueEyedBeast

Ho deciso di fare un approccio 2D a questa domanda ... Sì, ci sono 7 esolang 2D!

Ho preso ispirazione per ulteriori lingue da aggiungere dalla risposta di BlueEyedBeast (Foo, GolfScript)

<ESC>è il personaggio letterale di 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

Provalo online!uscitecorn

> <>

I comandi sono mostrati nell'ordine in cui appaiono

                                    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

Provalo online!(Solo copia e incolla) outputsweettea

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"

Provalo online! usciteapplepie (potrebbero essere necessari ˜20 secondi per l'esecuzione)

Python 2

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

Provalo online! (Solo copia e incolla) outputbiscuits

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

Provalo online! uscitesalad

Gol> <>

I comandi sono mostrati nell'ordine in cui appaiono

                                    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

Provalo online! usciteturkey

foo

Foo produce qualsiasi cosa tra virgolette doppie, ecco perché ho fatto attenzione a non usare virgolette doppie nelle altre lingue. Poiché "stuffing"è racchiuso tra virgolette, verrà stampato.

Provalo online! emette stuffinge quindi presenta un errore

Haystack (2015)

Questo utilizza l'interprete Haystack 2015 (non 2016) poiché la versione più recente non è valida. L'interprete per questo è haystack.pye non haystack_new.py

I comandi sono mostrati nell'ordine in cui appaiono

#                                 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

Questo programma emette

R
O
L
L
S

e una nuova riga dopo questo output (ehi, gli spazi bianchi non contano!)

GolfScript

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

Provalo online! uscitepecanpie

BF

Ho usato https://copy.sh/brainfuck/text.html per convertire il testo in BF. Anche se ce ne sono molti, istruzioni input, il codice BF viene eseguito indipendentemente da esso.

Provalo online! uscitegravy

scissione

Per iniziare un programma di Fissione, deve essere generato un atomo. Vediamo che ciò accade alla terza riga:

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

Provalo online! uscitecornbread

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

Provalo online! usciteapplecider

Sul serio

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

Provalo online! uscitedressing

Axo

(I comandi sono mostrati nell'ordine in cui si incontrano)

#>                                          blah blah
  !                                         rotate direction 90 degrees clockwise

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

Provalo online! uscitepumpkinpie

Pushy , Python e Brainfuck

Questo è il mio primo poliglotta, quindi non esagerare con me ... Per quelli che si lamentano del conteggio dei byte, sono 77 byte, ma questo è rilevante solo per il tiebreaker.

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

Pushy stampa 'turkey' con una nuova riga principale (oltre a un messaggio a 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 stampa 'gravy' , poiché la prima e l'ultima riga sono trattate come commenti.

Brainfuck ignora tutti gli altri personaggi e ad eccezione di quelli dell'ultima riga, che creano e stampano la parola "mais" .

Pip , BF , oOo CODE , > <> , Befunge-93 ( implementazione Quirkster ), Ouroboros , /// : 7 lingue, 175 byte

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

seme

Provalo online

Un gruppo di espressioni che vengono scartate silenziosamente (la maggior parte delle quali genera avvisi, se gli avvisi sono abilitati), con l'espressione "sTufFINg" alla fine che viene stampata.

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

Provalo online

Tutto tranne i >-[--[<]>+>-]<.++++++++++++.+++.----.,,,,commenti. Questo codice genera 99(il codice carattere per c) tramite il metodo più breve elencato su esolangs.org , quindi lo modifica per o,r e n. Il ,,,,tentativo di inserire quattro caratteri, ma ciò non influisce su nulla.

oOo CODICE

Tutto tranne le lettere viene ignorato. Raggruppando le lettere in tre, i codici recitano così:

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

e si traduce in questo codice BF ( provalo usando il traduttore Retina di Martin ):

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

quali usciterolls . (E, abbastanza interessante, è più breve del precedente BF per l'output corn, anche con a>< no-op aggiunta per allineare correttamente la capitalizzazione.)

> <>

Esegui> <> codice qui

La parte importante del codice:

/
        /ooooo;
>"YVaRg"^

L'IP viene riflesso verso l'alto, si avvolge e viene inviato verso destra. "YVaRg"spinge i codici dei caratteri di gRaVY. ooooogenera cinque lettere e; termina il programma.

Befunge-93

Il codice dipende da un comportamento indefinito e probabilmente funziona solo in questa implementazione .

La parte importante del codice:

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

/è divisione. La pila è vuota, quindi l'implementazione JavaScript che sto utilizzando divide 0da 0e spinte NaN.

'è un personaggio non riconosciuto. L'implementazione che sto usando, convenientemente, tratta i caratteri non riconosciuti come comandi Reflect. (Per una versione meno dipendente dall'implementazione, una possibile sostituzione sarebbe 1_.) Quindi l'IP va di nuovo a sinistra, si divide NaNper 0(ottenendo NaN) e si sposta all'altra estremità della linea.

Ora "yekRut"(spostando RTL) spinge i codici dei caratteri di tuRkeye ,,,,,,li emette. Infine, @termina il programma.

Ouroboros

Provalo qui

Ogni riga del codice è un "serpente" che viene eseguito in modo indipendente.

Snake 1

Dal momento che non ci sono istruzioni di output, l'unica parte importante del codice è f(: fspinge 15e (ingoia quel numero di personaggi dalla fine del serpente. Il codice ora è considerato terminare dopo .O. L'esecuzione continua fino alla fine del serpente e torna all'inizio. Ogni volta, il serpente si accorcia fino a quando non (viene inghiottito. Dato che l'IP è appena stato mangiato, il serpente interrompe l'esecuzione.

Snake 2

"saLaD"spinge i suoi codici carattere per ultimi; 1/divide il codice a barre di rper1 , lasciandolo invariato e ooooogenera cinque caratteri. ;rilascia un oggetto (no-op perché la pila è già vuota). 1(ingoia il puntatore dell'istruzione e si ferma.

Snake 3

"YVaRg"invia alcuni caratteri; quindi (ingoia un numero di caratteri pari alla parte superiore della pila, che risulta essere 89, il codice carattere diY . Mangiare 89 caratteri è sufficiente per ingoiare l'IP e interrompere l'esecuzione.

///

Provalo online usando l'implementazione Pip di ///

/'//elimina tutte le virgolette singole dal resto del programma (che non fa nulla perché non ce ne sono). Quindi, le bisCuItSuscite così come sono. Infine, il resto del codice è una sostituzione incompleta - ci sono solo due delle tre barre necessarie - quindi non fa nulla.

Cubix, Pushy, Brainfuck, V, Python 2 - 5 lingue, 89 85 byte

Il mio secondo poliglotta in assoluto - non molto golf, ma funziona:

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

_{(nota che ␛rappresenta il byte di escape letterale, x1B)}

• Stampe Cubix corn
• Stampe invadenti turkey
• Stampe Brainfuck ROLLS
• V stampe gravy
• Stampe di pitone salad

Cubix

Prova il programma online!

Cubix è un linguaggio dell'autore della sfida, ETHproductions. L'interprete Cubix legge il codice in questo modo:

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

Il codice viene eseguito in questo modo:

• 'salad - esegue alcune operazioni XOR irrilevanti nello stack, risulta in 115, 0, 0
• '#;- premi il codice char di #, quindi pop di nuovo (no-op)
• "nroc" - spingere i caratteri per "mais"
• w - sposta l'IP in modo da passare alla riga successiva in basso:
  • !@o; - stampa e pop l'ultimo elemento (termina se l'articolo è 0)
  • "-[--";;;; - invia questi caratteri ed eliminali (no-op)
  • {{ - no-op

troppo intraprendente

Prova il programma online!

Pushy è la mia lingua, ed esegue il codice in questo modo:

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

Prova il programma online!

Brainfuck ignora tutti i personaggi che non sono nel suo elenco di istruzioni, risultando in:

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

Quale stampa ROLLS. Si noti che ciò richiede un interprete con celle a capo, come quella fornita.

V (lingua Vim)

Prova il programma online!

V è stato creato da DJMcMayhem, uno dei nostri migliori golfisti di codice.

V è una versione basata sul programma dell'editor di testo Vim. La maggior parte dei personaggi prima di ESCessere scritti nel "file", ma ␛ddgigravyelimina tutto ciò e inserisce invece "gravy". Il contenuto del file alla fine del programma viene stampato.

Python 2

Prova il programma online!

Python è uno dei miei linguaggi pratici preferiti. Poiché #è un commento in Python, la maggior parte del programma viene ignorata. Il codice viene letto in questo modo:

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

Python / QBasic / Pip , 3 lingue, 41 byte

Più lingue probabilmente TBA.

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

Pitone

1è solo un'espressione che viene scartata. #inizia un commento. print("turkey")fa quello che dice, ed "salad"è un'altra espressione che viene scartata.

QBasic

1# è un numero di riga (di precisione doppia). print"corn"fa quello che dice. endtermina il programma. La seconda riga è sintatticamente valida ma mai eseguita.

seme

Quasi tutto è espressioni che vengono scartate. "corn":eprova ad assegnare ad una stringa letterale, che fallisce silenziosamente (a meno che gli avvisi non siano abilitati). "salad"è l'ultima espressione nel programma e quindi viene stampata.

PHP, JavaScript e BrainF * ck, 178 byte

La prima volta che ho mai provato un poliglotta - non mentirò, sono qui sopra la mia testa ...

golfed:

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

(Non ho osato scrivere un alimento del Ringraziamento nel codice HTML e contarlo come un'altra lingua ...)

Spiegazione:

Il codice deve essere salvato in un file .php per le parti PHP e JavaScript.

PHP:

Quando eseguito su un server PHP, viene letta la parte PHP del codice:

<?php echo "turkey";?>

Questo produce:

JavaScript:

Puoi chiamare la A()funzione JavaScript dalla console del browser:

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

Questo produce:

Brainf * ck

La parte Brainf * ck è ben nascosta nei commenti nella sezione JavaScript, quindi viene ignorata dalle parti PHP e JavaScript:

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

Quando l'intero file viene incollato in un IDE , questo genera:

Non avrei potuto fare la parte Brainf * ck senza questo sito Web da testo a BF. Inizialmente l'ho ottenuto per generare il codice per "mais" e poi, nel tentativo di imparare qualcosa su questo linguaggio folle, l'ho convertito in "sugo" ... o piuttosto "grave" ...

Python, Clojure, Javascript, Ruby: 4 lingue, 113 byte

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

Grazie a @ Sp3000 per la maggior parte del codice. Sorprendentemente, non dovevo nemmeno fare nulla per il suo originale, dovevo solo anteporre il codice Ruby.

///, SQL e JavaScript

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

Stessa costruzione dell'altro poliglotta orientato alle vacanze:

///

/*//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 byte

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

Famiglia Lisp qui. '()restituisce true in Clojure, quindi procede all'output di un simbolo turkey. PicoLisp e Common Lisp vanno in falso ramo; ""è vero in Common Lisp e quindi stampa il simbolo rolls, la stringa vuota è falsa in PicoLisp e quindi va alla stampacorn simbolo.

Controllalo online:

https://ideone.com/OD65LB - Clojure

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

https://ideone.com/B4x3ns - PicoLisp

CJam, Underload,> <>, 39 byte

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

Cosa vede CJam

• 'v;: Un personaggio letterale che viene immediatamente scartato
• "(Turkey)S";: Una stringa letterale che viene immediatamente scartata
• "Gravy": Spinge la stringa Gravy nello stack
• "\n'nroC'oooo;";: Una stringa letterale che viene immediatamente scartata.

Alla fine dell'esecuzione, lo stack viene emesso, il che significa che viene stampato "Gravy".

Cosa vede Underload

• 'v;": Alcuni comandi non validi che vengono ignorati
• (Turkey)S: Invia la stringa "Turchia" e la emette
• ";"Gr: Alcuni comandi non validi che vengono ignorati
• a: Ciò causa un segfault sull'interprete TIO poiché lo stack è vuoto. L'esecuzione è terminata.

Cosa vede <>

• 'v;"(Turkey)S";"Gravy""spinge un gruppo di personaggi nello stack (che vengono ignorati). L'IP quindi torna indietro.
• v invia l'IP verso il basso.
• >'nroC'oooo spinge i caratteri nella stringa "Mais" e li emette.
• ;termina l'esecuzione. Tutti gli altri personaggi vengono ignorati.