Wie wäre es mit einer Herausforderung, bei der die Ausgabe zweisprachig sein kann, nach all dem Spaß, den wir in der ( jüngsten ) Vergangenheit mit mehrsprachigen Herausforderungen hatten ?

Ihre Antwort muss eine boolesche Eingabe akzeptieren bund den Text "true"oder ausgeben "false". Derselbe Code muss ausgegeben werden, wenn er in einer anderen Sprache ausgeführt wird."waar" oder , "onwaar"oder jede andere Übersetzung von trueund false.

Eingang

• Input ist eine klar unterscheidbare Wahrheit / Falschheit. Zulässig sind die Istwerte T / F, ein Bit, int oder eine (leere) Zeichenkette.
• Die Eingabe muss für alle Teile Ihrer Einreichung gleich sein.

Ausgabe

• Die Ausgabe kann von einer Funktion zurückgegeben werden, in die geschrieben wurde STDOUT in ein Popup-Fenster , dort platziert, in 3D gedruckt und per Post verschickt werden.

• Die Ausgabe muss den Status von darstellen b . Eine "Wahrheit" muss also "wahr", "waar" ... ausgeben, und "falsey" sollte zu "falsch", "onwaar" usw. führen.

• Unterschiedliche Sprachen können unterschiedliche Ausgabemethoden verwenden.

Verwendete Sprachen

• Einer Ihrer Ausgänge MUSS "true"und sein "false".

• Unterschiedliche Versionen von Programmiersprachen zählen für diese Herausforderung als unterschiedliche Sprachen.

• Unterschiedliche Dialekte einer menschlichen Sprache zählen für diese Herausforderung als unterschiedliche Sprachen.

• Sie können die Mehrsprachigkeit auf mehr als zwei Programmiersprachen erweitern. Jede Programmiersprache muss eine eigene menschliche Sprache ausgeben.

Die Antwort mit den meisten Sprachen wird zum Gewinner erklärt. Bei Gleichstand wird bytecount berücksichtigt.

Dyalog APL , 243 237 Bytes : 14 Sprachen, erweiterbar auf 131 *

-6 Bytes dank Soaku .

Benötigt, ⎕IO←0was auf vielen Systemen Standard ist. Fordert zur Eingabe von 0oder auf 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'

Je nach Version (9.0 bis 16.0, mit Nebenversionen) erfolgt die Ausgabe in Englisch, Spanisch, Portugiesisch, Deutsch, Vietnamesisch, Französisch, Türkisch, Italienisch, Polnisch, Sundanesisch, Philippinisch, Yoruba, Usbekisch oder Rumänisch, jedoch ohne diakritische Zeichen.

 ⎕AV⍳'ëáàÆÅÄòðÓÈÇ'in den Indizes des A tomic V ector (151 142 141 133 132 131 122 121 111 102 101 96)

((... )⍳... )finde die Position von

 ⍎ die ausgewertet

 ⎕D∩⍨Schnittpunkt von D igits und

 4↑ die vier * ersten Zeichen von

 1⊃ das zweite Element von

 #⎕WG'APLVersion' die Versionsnummer

(... )⊃dann wähle damit aus

⎕⊃ das Eingabe'te (0: erstes; 1: zweites) Element von

s¨Die Funktion s (die wir in Kürze definieren werden) wird auf jede der Funktionen angewendet

⌽ das Gegenteil von

(s←{... }) s angewendet auf - wobei s definiert ist als

 1↓¨ das erste Zeichen aus jedem von

 ⍵⊂⍨ das Argument, wo aufgeteilt

 ⍵= Die Zeichen des Arguments sind gleich

 ⊃⍵ das erste Zeichen des Arguments

';,true,adevarat,... ,falsch',diese Zeichenfolge vorangestellt

18⍴',falso' Achtzehn Zeichen, die zyklisch aus dieser Zeichenfolge entnommen wurden

* Seit Version 12.1 enthält die Versionsnummer die Build-Nummer. Durch Erhöhen der Anzahl der Zeichen aus dieser Zeichenfolge können alle 131 lateinischen Skriptsprachen problemlos abgedeckt werden .

6 Sprachen, 169 Bytes

Erwartet 0\noder 1\nals Eingabe und druckt Wörter in:

• Python 2 (Niederländisch vals/waar ),
• Python 3 (Französisch faux/vrai ),
• Ruby (Englisch false/true ),
• CJam (Norwegisch usant/sant ),
• Golfscript (dänisch usand/sand ),
• Befunge-93 (Italienisch 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",,,,,@

Alle Pilze, 6 Sprachen, 146 Bytes

💥 Jetzt in 3D! 💥

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

Der Klarheit halber habe ich die beiden Codeebenen getrennt, damit Sie sehen können, wie sie überlagert sind. Auf der Festplatte werden diese beiden Blöcke am Ende der obigen Zeile durch ein Formularvorschubzeichen getrennt.

   h"vals"0"waar"<

Die Regeln besagten, dass verschiedene Versionen einer Sprache als separate Sprachen gelten, sodass es sich bei dieser um sechs Versionen von Funge / Befunge handelt. :)

• Befunge-93 (Spanisch - cierto / falso) Probieren Sie es online!
• Befunge-96 (lateinisch - verum / falsum) Probieren Sie es online!
• Befunge-97 (Französisch - Vrai / Faux) Probieren Sie es online!
• Befunge-98 (Englisch - wahr / falsch) Probieren Sie es online!
• Unefunge-98 (norwegisch - ekte / falsk)
• Trefunge-98 (Niederländisch - waar / vals)

Dank Dennis können nun alle Befunge-Versionen online bei TIO getestet werden . Derzeit gibt es jedoch keine funktionierenden Implementierungen der Unefunge- und Trefunge-Varianten. Für diese würde ich Rc / Funge empfehlen .

Awird in Befunge 93 und 96 ignoriert, ist jedoch der Befehl Über Gesicht in 97 und wird in 98 nicht unterstützt und wird daher wiedergegeben. Dies bedeutet, dass 93 und 96 dem folgenv unten verlaufen, während 97 und 98 auf die gegenüberliegende Seite des Spielfelds gewickelt werden.

In Befunge 96 markiert ein ;gefolgt von einem Leerzeichen am Anfang der Zeile diese als Kommentar, sodass diese Zeile übersprungen wird und der Interpreter in >die dritte Zeile übergeht . Im Jahre 93 folgt der Dolmetscher dem> der zweiten Zeile.

Der 97/98-Pfad wird in der ersten Zeile von rechts nach links fortgesetzt. Dabei wird der Abschnitt innerhalb der ;Kommentarmarkierungen übersprungen , der &Befehl überbrückt und schließlich die U-Bend-Sequenz erreichtv<^< . In Unefunge werden diese Richtungsänderungen nicht unterstützt, sodass der Interpreter die Richtung umkehrt und den zuvor übersprungenen Abschnitt in den Kommentaren ausführt. In Befunge / Trefunge geht es links weiter.

In Befunge 97 wird der mBefehl nicht unterstützt und daher übersprungen, sodass der Interpreter in der ersten Zeile fortgesetzt wird. In 98 ist es nur 3D, so dass es in Befunge (2D) reflektiert wird und der Interpreter vrechts davon bis zur vierten Zeile folgt. In Trefunge (3D) ist es ein High-Low Zweig, der eine Ebene entlang der Z-Achse in die zweite Ebene überträgt.

Anders als im Unefunge-Fall haben wir also jede Version, die ihr Zeichenfolgenpaar aus einer separaten Zeile sammelt, bevor sie zu einem der &Befehle geleitet wird, um die Benutzereingabe zu erhalten. Diese Codepfade verschmelzen dann alle über die ^Befehle in der zweiten Spalte und leiten den Programmfluss nach oben durch die Oberseite des Spielfelds, wobei sie sich wieder nach unten drehen.

Schließlich haben wir die ^_^Reihenfolge, in der anhand der Benutzereingaben entschieden wird, welchem ​​Pfad zu folgen ist. Wenn 0 , gehen wir direkt zu der Ausgabesequenz ( >:#,_), in der der falsche String geschrieben wird. Bei 1 wird zuerst ausgeführt, >_wodurch die erste Zeichenfolge aus dem Stapel gelöscht und somit die wahre Zeichenfolge ausgegeben wird .

5 Sprachen, 249 Bytes

Hinweis: Die Zeichen \rund \esind wörtliche Zeilenvorschub- und Escapezeichen, müssen jedoch \x5bunverändert sein, da sich Ruby ansonsten über die Zeichenklasse im regulären Ausdruck beschwert.

Ein bisschen zu spät zur Party, und keineswegs ein Gewinner, aber ich fing an, an einer Polyglotte für die Erntedank-Herausforderung zu arbeiten und dachte, es könnte ein bisschen zu spät sein, also verwandelte es sich in diese!

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

Erläuterung

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

Hier setzen wir auf q, 0//1was ist 0, dann haben wir eine '''Zeichenkette, die den größten Teil des anderen Codes enthält, speichern ein Array, das Falseund Trueund anzeigt 0und 1weisen die Eingabe zu b(was sein sollte 0oder 1zu bedeuten Falsyund Truthy), dann printden bth-Index von a, zeigt Falseoder True.

Ruby: 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])

Wie beim Python-Skript setzen wir die Variable q, aber in Ruby wird dies auf gesetzt 0 / /1;'''<?die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));?>/.to_s.ord, da Ruby dies 0/als "Null geteilt durch" und das folgende /als "Beginn des Regex-Literal" aufteilt . Mit diesem Literal kann ich den PHP-Code verbergen und Pythons starten '''. Wir müssen hinzufügen, .to_s.ordweil der richtige Operand a sein /muss Fixnum. Danach definieren wir eine Funktion input()und die Variable Trueund Falseenthalten ihre französischen Gegenstücke und starten schließlich eine Zeichenkette, 'die in die nächste Zeile übergeht. Schließlich erstellen wir ein Array, adas "Vrai"und enthält, "Faux"und wählen sie mit der input()ed-Nummer 0oder aus 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, die q=..=, q+...+und q-...-werden Blöcke Literale mit ungewöhnlichen delimiters zitiert, in dem obigen Code ich diese ersetzt haben '...'. Der größte Teil des Codes ist in einer Literalzeichenfolge enthalten, aber wir definieren sub a(die ein <><! Enthält ), das prüft, ob STDINkleiner als 1ist und entweder Waaroder zurückgibtVals . Die print(a[b])tatsächlich prints das Ergebnis der Aufruf sub amit und Argument von [b]denen ist ein ArrayRef, die den Bare-Wort enthält 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])

Die erste Zeile wird meistens von der Division auskommentiert 0//1( //ist ein Zeilenkommentar in JavaScript), also setzen wir einfach qauf0 . In der nächsten Zeile werden die JS-Funktionen ihren Python-Namen und Einstellungsvariablen zugeordnetTrue und damit False, dass sie die italienischen Zeichenfolgen sind. Schließlich führen wir dasselbe aus wie den Ruby-Code, setzen a auf ein Array der italienischen Wörter und wählen mit einem inputvon 0oder aus 1.

PHP: Ekte/Falsk

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

Da PHP nur Code ausführt <?...?>, der so ausgegeben wird, wie er ist, gibt unser Code hier einfach einen Zeilenvorschub aus (um zum Anfang der aktuellen Zeile zurückzukehren) und die ANSI-Escape-Sequenz, um das Ende der aktuellen Zeile zu löschen Zeile, gefolgt von entweder Ekteoder Falskabhängig davon, ob das eingegebene Zeichen ( 0oder 1) wahr oder falsch ist.

Python, Python - 28 Bytes

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

C #, Java, 104 Bytes

Golf gespielt:

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 + "";
    }
  }

Prüfung:

C #

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

Java

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

Erläuterung:

Beim Aufruf ToString()oder toString()auf einem Boolean in C # und Java bzw. druckt C # die Zeichenfolge mit einem Kapital ersten Buchstaben, Trueund False, aber Java druckt alles in Kleinbuchstaben trueund false.

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

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

2 Sprachen, 60 Bytes

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

Sprachen sind:

• Gelee true false
• Python3 waar onwaar

Hinweis: Es gibt UTF-8-Bytes, keine Jelly-Bytes.

Lua / JavaScript, 68 Bytes

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

Ich weiß nicht, warum ich Golf gespielt habe. Ich fühlte mich einfach so.

JavaScript / BF

In beiden Sprachen wird keine Eingabe als falsch und jede Eingabe als wahr betrachtet.

Wenn Sie die Struktur des Programms um 90 Grad nach links gedreht sehen, sehen die BF-Symbole aus wie Türme in einer Stadt :)

Probieren Sie es online aus (BF true testcase)!

Probieren Sie es online aus (BF falscher Testfall)!

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

Erläuterung

JavaScript

Wenn der prompttrue ist (dh nicht leer, weil promptein String zurückgegeben wird), wird ausgegeben trueoder sonst ausgegeben false.

BF

Ausgaben sand(dänisch für wahr), wenn eine Eingabe vorhanden ist, oder Ausgaben usand(falsch), wenn die Eingabe leer ist.

TL; DR Wenn die Eingabe nicht leer (dh wahr) ist, geben Sie nichts aus. Wenn die Eingabe leer ist (dh falsch), wird sie ausgegeben u. Dann wird unabhängig davon, ob die Eingabe wahr oder falsch ist, ausgegeben sand.

Ich habe mich von https://esolangs.org/wiki/Brainfuck_algorithms inspirieren lassen mit denen ich die Logik meines Programms erstellt habe.

Eingaben übernehmen. Wenn die Eingabe nicht leer ist, erhöhen Sie den Speicher, nennen wir diese Zelle "Zelle A". If-Anweisung beenden

>
,[
>+
<<
]>

Vergleicht den Wert von "Zelle A" mit 0. Wenn sie gleich sind, lass "Zelle B" sein 1, oder lass es sein 0.

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

Wenn "Zelle B" 1 ist, wird ausgegeben u. Schließen Sie die if-Anweisung

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

Ausgabe sand

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