Dopo tutto il divertimento che abbiamo avuto con le sfide poliglotta nel ( recente ) passato, che ne dici di una sfida in cui l'output può essere in due lingue?

La tua risposta deve accettare input booleani be generare il testo "true"o "false". Lo stesso codice deve uscita, quando eseguito in un'altra lingua, "waar"o "onwaar"o qualsiasi altra definizione di truee false.

Ingresso

• L'input è una verità / falsità chiaramente distinguibile. Sono ammessi i valori effettivi T / F, un bit, int o (vuoto) stringa.
• L'input deve essere lo stesso per tutte le parti dell'invio.

Produzione

• L'output può essere restituito da una funzione, scritto in STDOUT, posizionato in una finestra popup, stampato in 3D e spedito ecc.

• L'output deve rappresentare lo stato di b. Quindi un 'verità' deve produrre 'vero', 'waar' ... e 'falso' dovrebbe portare a 'falso', 'onwaar', ecc.

• Lingue diverse possono utilizzare metodi di output diversi.

Lingue utilizzate

• Una delle tue uscite DEVE essere "true"e "false".

• Versioni diverse di linguaggi di programmazione contano come lingue diverse per questa sfida.

• Dialetti diversi di una lingua umana contano come lingue diverse per questa sfida.

• È possibile estendere il poliglotta a più di due linguaggi di programmazione. Ogni linguaggio di programmazione deve produrre un linguaggio umano distinto.

La risposta con la maggior parte delle lingue incorporate sarà dichiarata vincitrice. Quando legato, viene considerato bytunt.

Dyalog APL , 243 237 byte : 14 lingue, estendibile a 131 *

-6 byte grazie a Soaku .

Richiede il ⎕IO←0valore predefinito su molti sistemi. Richiede l'immissione di 0o 1.

((⎕AV⍳'ëáàÆÅÄòðÓÈÇ')⍳⍎⎕D∩⍨4↑1⊃#⎕WG'APLVersion')⊃⎕⊃s¨⌽(s←{1↓¨⍵⊂⍨⍵=⊃⍵})';,true,adevarat,haqiqiy,otito,tunay,bener,prawda,dogru,vrai,that,wahr,vero,verdade,cierto;,false,fals,yolg''on,eke,mali,palsu,falsz,yanlis,faux,sai,falsch',18⍴',falso'

A seconda della versione (da 9.0 a 16.0, con versioni secondarie) produce in inglese, spagnolo, portoghese, tedesco, vietnamita, francese, turco, italiano, polacco, sundanese, filippino, yoruba, uzbeko o rumeno, anche se senza segni diacritici.

 ⎕AV⍳'ëáàÆÅÄòðÓÈÇ'negli indici di A Tomic V ector (151 142 141 133 131 122 121 132 111 102 101 96)

((... )⍳... )trova la posizione di

 ⍎ il valutato

 ⎕D∩⍨intersezione di D igits e

 4↑ i quattro * primi caratteri di

 1⊃ il secondo elemento di

 #⎕WG'APLVersion' il numero di versione

(... )⊃quindi usalo per scegliere tra

⎕⊃ l'elemento input'th (0: first; 1: second) di

s¨la funzione s (che definiremo a breve) applicata a ciascuno di

⌽ il contrario di

(s←{... }) s applicato a - dove s è definito come

 1↓¨ il primo personaggio è caduto da ciascuno di

 ⍵⊂⍨ l'argomento partizionato dove

 ⍵= i caratteri dell'argomento sono uguali a

 ⊃⍵ il primo personaggio dell'argomento

';,true,adevarat,... ,falsch',questa stringa è stata anteposta

18⍴',falso' diciotto caratteri presi ciclicamente da quella stringa

* Dalla versione 12.1, il numero di versione include il numero di build, quindi aumentando il numero di caratteri presi da questa stringa, è facile coprire tutti i 131 linguaggi di script latini .

6 lingue, 169 byte

Si aspetta 0\no 1\ncome input e stampa le parole in:

• Python 2 (olandese vals/waar),
• Python 3 (francese faux/vrai),
• Ruby (inglese false/true),
• CJam (norvegese usant/sant),
• Golfscript (danese usand/sand),
• Befunge-93 (italiano falso/vero).

"#{puts gets>?1;exit}"" "#"& 1v
""
print('vwfvaaarlauasrxi'[int(1/2*4+int(input()))::4])
""#";;;;ri"u">"sant"+o
""""
__END__
]0=~"u">"sand"""#@,,,,"vero"  _"oslaf",,,,,@

Tutti i funghi, 6 lingue, 146 byte

💥 Ora in 3D! 💥

A vv"faux"0"vrai"mv#<v&#;9*j"kslaf"6j"etke">:#,_@;
; >"otreic"0"oslaf"v^<
&^>"murev"0"muslaf">
&^&<"false"0"true"<
>_>:#,_@
^_^

Per chiarezza ho separato i due piani di codice in modo da poter vedere come sono stratificati. Su disco questi due blocchi verrebbero separati con un carattere di avanzamento del modulo alla fine della riga sopra.

   h"vals"0"waar"<

Le regole dicevano che le diverse versioni di una lingua contano come lingue separate, quindi questa è sei versioni di Funge / Befunge. :)

• Befunge-93 (spagnolo - cierto / falso) Provalo online!
• Befunge-96 (latino - verum / falsum) Provalo online!
• Befunge-97 (francese - vrai / faux) Provalo online!
• Befunge-98 (inglese - vero / falso) Provalo online!
• Unefunge-98 (norvegese - ekte / falsk)
• Trefunge-98 (olandese - waar / vals)

Grazie a Dennis , ora tutte le versioni di Befunge possono essere testate online su TIO . Al momento non ci sono implementazioni funzionanti delle varianti Unefunge e Trefunge, quindi per quelle che consiglierei Rc / Funge .

Aviene ignorato in Befunge 93 e 96, ma è il comando About Face in 97 e non è supportato in 98 e quindi riflette. Ciò significa che 93 e 96 seguono il vverso verso il basso mentre 97 e 98 si avvolgono sul lato opposto del campo di gioco.

In Befunge 96 un ;seguito da spazio all'inizio della riga lo segna come un commento, in modo che quella riga venga saltata e l'interprete continui alla >terza riga. Nel 93, tuttavia, l'interprete segue >la seconda riga.

Il percorso 97/98 prosegue sulla prima linea da destra a sinistra, saltando sulla sezione all'interno dei ;indicatori di commento, colma il &comando, fino a raggiungere la sequenza U-bend v<^<. In Unefunge, questi cambi di direzione non sono supportati, quindi l'interprete inverte la direzione ed esegue la sezione precedentemente ignorata nei commenti. In Befunge / Trefunge continua a sinistra.

In Befunge 97 il mcomando non è supportato e quindi ignorato, quindi l'interprete continua lungo la prima riga. Nel 98 è solo 3D, quindi si riflette in Befunge (2D) e l'interprete segue vla sua destra fino alla quarta riga. In Trefunge (3D) è un ramo alto-basso che trasferisce di un livello lungo l'asse z sul secondo piano.

Quindi, a parte il caso Unefunge, ogni versione raccoglie la coppia di stringhe da una riga separata prima di essere indirizzata a uno dei &comandi per ottenere l'input dell'utente. Quei percorsi di codice poi si fondono tutti insieme tramite i ^comandi nella seconda colonna, indirizzando il flusso del programma verso l'alto attraverso la parte superiore del campo di gioco, avvolgendosi di nuovo verso il basso.

Finalmente abbiamo la ^_^sequenza che decide quale percorso seguire in base all'input dell'utente. Se 0 , andiamo direttamente alla sequenza di output ( >:#,_) scrivendo la falsa stringa. Se 1 , eseguiamo prima ciò >_che cancella la prima stringa dallo stack e quindi genera la stringa vera .

5 lingue, 249 byte

Nota: i \re \esono letterali avanzamenti di riga e caratteri di escape, ma \x5bdevono essere così come sono, altrimenti Ruby si lamenta della classe di caratteri nella regex.

Un po 'in ritardo alla festa, e non un vincitore, ma ho iniziato a lavorare su un poliglotta per la sfida del Ringraziamento e ho sentito che potrebbe essere un po' tardi, quindi trasformalo in questo!

q=0//1;'''<?die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));?>/.to_s.ord;def input()gets.to_i;end;q=+q+0;True="Vrai";False="Faux";'+;sub a{<><1?Vals:Waar}q-
input=prompt;print=alert;True="Vero";False="Falso"//'#'''
a=[False,True];b=input();1-+1;print(a[b])

Spiegazione

Python: True/False

q=0//1;'''<?die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));?>/.to_s.ord;def input()gets.to_i;end;q=+q+0;True="Vrai";False="Faux";'+;sub a{<><1?Vals:Waar}q-
input=prompt;print=alert;True="Vero";False="Falso"//'#'''
a=[False,True];b=input();1-+1;print(a[b])

Qui abbiamo impostato qa 0//1che è 0, allora abbiamo una '''stringa che contiene la maggior parte del altro codice, memorizzare un array contenente Falsee Truee indicies 0e 1rispettivamente, assegnare l'ingresso b(che dovrebbe essere 0o 1per significare Falsye Truthy) poi l'indice di th di , mostrando o .printbaFalseTrue

Rubino: Vrai/Faux

q=0//1;'''<?die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));?>/.to_s.ord;def input()gets.to_i;end;q=+q+0;True="Vrai";False="Faux";'+;sub a{<><1?Vals:Waar}q-
input=prompt;print=alert;True="Vero";False="Falso"//'#'''
a=[False,True];b=input();1-+1;print(a[b])

Come con lo script Python, impostiamo la variabile q, ma in Ruby questa è impostata su 0 / /1;'''<?die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));?>/.to_s.ord, poiché Ruby lo suddivide 0/come "zero diviso per" e il seguente /come "inizio del regex letterale". Usando questo letterale sono in grado di nascondere il codice PHP e iniziare Python '''. Dobbiamo aggiungere .to_s.ordperché l'operando giusto /deve essere un Fixnum. Dopo questo definiamo una funzione input()e la variabile Truee Falseper contenere le loro controparti francesi e infine iniziamo una stringa 'che continua sulla riga successiva. Infine creiamo un array ache contiene "Vrai"e "Faux"e li selezioniamo usando il input()numero ed 0o 1.

Perl: Waar/Vals

'0//1;\'\'\'<?die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));?>/.to_s.ord;def input()gets.to_i;end;q}+q{0;True="Vrai";False="Faux";\'';sub a{<><1?Vals:Waar}'
input=prompt;print=alert;True="Vero";False="Falso"//\'#\'\'\'
a=[False,True];b=input();1'+1;print(a[b])

In Perl, i q=..=, q+...+e q-...-blocchi sono quotati letterali utilizzando delimitatori insoliti, nel codice sopra ho sostituito questi con '...'. La maggior parte del codice è contenuta in una stringa letterale, ma definiamo sub a(che contiene un <><!) Che controlla se STDINè inferiore a 1, restituendo Waaro Vals. In print(a[b])realtà printè il risultato della chiamata a sub awith e l'argomento di [b]cui è un ArrayRef che contiene la parola nuda b.

JavaScript: Vero/Falso

q=0//1;'''<?die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));?>/.to_s.ord;def input()gets.to_i;end;q=+q+0;True="Vrai";False="Faux";'+;sub a{<><1?Vals:Waar}q-
input=prompt;print=alert;True="Vero";False="Falso"//'#'''
a=[False,True];b=input();1-+1;print(a[b])

La prima linea è per lo più commentata dalla divisione 0//1( //è riga di commento in JavaScript) e quindi abbiamo appena impostato qa 0. La riga successiva si occupa di mappare le funzioni JS sui loro nomi Python e impostare le variabili Truee Falsedi essere le stringhe italiane, infine eseguiamo lo stesso del codice Ruby, impostando un array di parole italiane e selezionando usando un inputdi 0o 1.

PHP: Ekte/Falsk

die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));

Poiché PHP esegue solo il codice tra <?...?>tutto il resto viene emesso così com'è, quindi il nostro codice qui stampa semplicemente un avanzamento di riga (per riportarci all'inizio della riga corrente) e la sequenza di escape ANSI per cancellare fino alla fine della corrente linea, seguita da una Ekteo dall'altra a Falskseconda che il carattere di input ( 0o 1) sia vero o falso.

Pyth, Python - 28 byte

#>"onwaar"yQ.q
print input()

C #, Java, 104 byte

golfed:

String M(Boolean b){String s=b+"";if(s=="True")return "Wahr";if(s=="False")return "Falsch";return b+"";}

Ungolfed:

  class MultiLingualChallenge
  {
    public String M(Boolean b)
    {
      String s = b + "";
      if (s == "True")
        return "Wahr";
      if (s == "False")
        return "Falsch";
      return b + "";
    }
  }

Test:

C #

Console.WriteLine(new MultiLingualChallenge().M(true));
//Wahr
Console.WriteLine(new MultiLingualChallenge().M(false));
//Falsch

Giava

System.out.println(new MultiLingualChallenge().M(true));
//true
System.out.println(new MultiLingualChallenge().M(false));
//false

Spiegazione:

Quando si chiama ToString()o toString()su un booleano rispettivamente in C # e Java, C # stampa la stringa con la prima lettera maiuscola Truee False, ma Java stampa tutto in minuscolo truee false.

Console.WriteLine(true+"");
//True

System.out.println(true+"");
//true

2 lingue, 60 byte

print('onwaar'[2*int(input()):]);1#¶ị“¡ẈẆ“⁸1»

Le lingue sono:

• Gelatina true false
• python3 waar onwaar

Nota: ci sono byte UTF-8, non byte Jelly.

Lua / JavaScript, 68 byte

x=1//1print(...and"true"or"false")
--x;alert(prompt()?"vrai":"faux")

Non so perché l'ho giocato a golf; Mi è solo piaciuto.

JavaScript / BF

In entrambe queste lingue, nessun input è considerato falso e qualsiasi input è considerato vero.

Quando vedi la struttura del programma ruotata di 90 gradi a sinistra, i simboli BF sembrano torri in una città :)

Provalo online (BF true testcase)!

Provalo online (BF false testcase)!

console.log(prompt()?"true":"false")
/*
           >,[>
+          <<]>>[->-<]
+          >[<->[-]]<>[-]<[>>
+++        [->
++++       <]>[->
++++++++++ <]>---.>]>
++++++++++ [->
++++++++++ <]
+++        [->
+++++      <]>.<
++++       [->----<]>--.<
+++        [->
++++       <]>
+          .<
+++        [->---<]>-.
*/

Spiegazione

JavaScript

Se il valore promptè true (ovvero non vuoto perché promptrestituisce una stringa), output trueo output false.

BF

Output sand(danese per vero) se c'è un input, oppure output usand(falso) se l'input è vuoto.

TL; DR Se l'input non è vuoto (ovvero true), non emettere nulla. Se input è vuoto (cioè falso), output u. Quindi, indipendentemente dal fatto che l'input sia vero o falso, l'output sand.

Ho preso ispirazione da https://esolangs.org/wiki/Brainfuck_algorithms con cui ho costruito la logica del mio programma.

Prendi input. Se l'input non è vuoto, incrementa la memoria, chiamiamo questa cella "Cella A". Termina if-statement

>
,[
>+
<<
]>

Confronta il valore di "Cella A" con 0. Se sono uguali, sia "Cella B" 1, oppure sia 0.

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

Se "Cella B" è 1, quindi emettere u. Chiudi if-statement

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

Produzione sand

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

Haskell, JavaScript, Python, 115 byte

q=1//1#1;f True="waar";f False="false";a//b=0;a#b=0{-
1//1;f=lambda x:"wahr"if x else"falsch";"""
f=x=>x+[]//"""#-}