Après tout le plaisir que nous avons eu avec les défis polyglottes dans le passé ( récent ), que diriez-vous d'un défi où la sortie peut être en deux langues?

Votre réponse doit accepter la saisie booléenne bet sortir le texte "true"ou "false". Le même code doit à la sortie, lorsqu'il est exécuté dans une autre langue, "waar"ou "onwaar"ou toute autre traduction trueet false.

Contribution

• L'entrée est une vérité / falsey clairement reconnaissable. Sont admises les valeurs réelles T / F, un bit, un entier ou une chaîne (vide).
• L'entrée doit être la même pour toutes les parties de votre soumission.

Production

• La sortie peut être retournée par une fonction, écrite STDOUT, placée dans une fenêtre contextuelle, imprimée en 3D et envoyée par la poste, etc.

• La sortie doit représenter l'état de b. Ainsi, un "véridique" doit produire "vrai", "waar" ... et "falsey" devrait conduire à "faux", "onwaar", etc.

• Différentes langues peuvent utiliser différentes méthodes de sortie.

Langues utilisées

• L'une de vos sorties DOIT être "true"et "false".

• Différentes versions des langages de programmation comptent comme des langages différents pour ce défi.

• Différents dialectes d'une langue humaine comptent comme différentes langues pour ce défi.

• Vous pouvez étendre le polyglotte à plus de deux langages de programmation. Chaque langage de programmation doit produire un langage humain distinct.

La réponse avec le plus de langues incorporées sera déclarée gagnante. Une fois lié, le bytecount est pris en compte.

Dyalog APL , 243 237 octets : 14 langues, extensible à 131 *

-6 octets grâce à Soaku .

Requiert ⎕IO←0ce qui est par défaut sur de nombreux systèmes. Invite à saisir 0ou 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'

Selon la version (9.0 à 16.0, avec les versions mineures), il sort en anglais, espagnol, portugais, allemand, vietnamien, français, turc, italien, polonais, Sundanais, philippin, yoruba, ouzbek ou roumain, mais sans signes diacritiques.

 ⎕AV⍳'ëáàÆÅÄòðÓÈÇ'dans les indices de la A tomic V ecteur (151 142 141 133 131 122 121 132 111 102 101 96)

((... )⍳... )trouver la position de

 ⍎ l'évaluation

 ⎕D∩⍨intersection des chiffres D et

 4↑ les quatre * premiers caractères de

 1⊃ le deuxième élément de

 #⎕WG'APLVersion' le numéro de version

(... )⊃puis utilisez-le pour choisir parmi

⎕⊃ l'élément input'th (0: premier; 1: second) de

s¨la fonction s (que nous définirons prochainement) appliquée à chacun

⌽ l'inverse de

(s←{... }) s appliqué à - où s est défini comme

 1↓¨ le premier caractère est tombé de chacun

 ⍵⊂⍨ l'argument partitionné où

 ⍵= les caractères de l'argument sont égaux à

 ⊃⍵ le premier caractère de l'argument

';,true,adevarat,... ,falsch',cette chaîne a été ajoutée à

18⍴',falso' dix-huit caractères tirés cycliquement de cette chaîne

* Depuis la version 12.1, le numéro de version inclut le numéro de build, donc en augmentant le nombre de caractères pris dans cette chaîne, il est facile de couvrir les 131 langages de script latins .

6 langues, 169 octets

Attend 0\nou 1\nen entrée et imprime les mots en:

• Python 2 (néerlandais vals/waar),
• Python 3 (français faux/vrai),
• Ruby (anglais false/true),
• CJam (norvégien usant/sant),
• Golfscript (danois usand/sand),
• Befunge-93 (italien 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",,,,,@

Tous les Funges, 6 langues, 146 octets

💥 Maintenant en 3D! 💥

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

Pour plus de clarté, j'ai séparé les deux plans de code afin que vous puissiez voir comment ils sont superposés. Sur le disque, ces deux blocs seraient séparés par un caractère de saut de page à la fin de la ligne ci-dessus.

   h"vals"0"waar"<

Les règles disaient que différentes versions d'une langue comptent comme des langues distinctes, donc celle-ci est six versions de Funge / Befunge. :)

• Befunge-93 (espagnol - cierto / falso) Essayez-le en ligne!
• Befunge-96 (latin - verum / falsum) Essayez-le en ligne!
• Befunge-97 (français - vrai / faux) Essayez-le en ligne!
• Befunge-98 (anglais - vrai / faux) Essayez-le en ligne!
• Unefunge-98 (norvégien - ekte / falsk)
• Trefunge-98 (néerlandais - waar / vals)

Grâce à Dennis , toutes les versions de Befunge peuvent désormais être testées en ligne sur TIO . Il n'y a pas actuellement d'implémentations de travail des variantes Unefunge et Trefunge, donc pour ceux que je recommanderais Rc / Funge .

Aest ignoré dans Befunge 93 et ​​96, mais est la commande About Face en 97 et n'est pas prise en charge en 98 et se reflète donc. Cela signifie que 93 et ​​96 suivent la vdescente tandis que 97 et 98 s'enroulent du côté opposé du terrain de jeu.

Dans Befunge 96, un ;espace suivi au début de la ligne le marque comme un commentaire, de sorte que cette ligne est sautée et que l'interprète continue >sur la troisième ligne. En 93, cependant, l'interprète suit le >sur la deuxième ligne.

Le chemin 97/98 continue sur la première ligne de droite à gauche, sautant la section à l'intérieur des ;marqueurs de commentaire, relie la &commande, pour finalement atteindre la séquence de U-bend v<^<. Dans Unefunge, ces changements de direction ne sont pas pris en charge, donc l'interpréteur inverse la direction et exécute la section précédemment ignorée dans les commentaires. Dans Befunge / Trefunge, il continue vers la gauche.

Dans Befunge 97, la mcommande n'est pas prise en charge et est donc ignorée, donc l'interprète continue le long de la première ligne. En 98, il est uniquement en 3D, donc il se reflète dans Befunge (2D) et l'interprète suit le và droite jusqu'à la quatrième ligne. Dans Trefunge (3D), c'est une branche haute-basse qui transfère un niveau le long de l'axe z vers le deuxième plan.

Donc, à part le cas Unefunge, nous avons chaque version rassemblant leur paire de chaînes à partir d'une ligne distincte avant d'être dirigée vers l'une des &commandes pour obtenir l'entrée utilisateur. Ces chemins de code fusionnent ensuite tous via les ^commandes de la deuxième colonne, dirigeant le flux du programme vers le haut à travers le haut du champ de lecture, puis se retournant vers le bas.

Enfin, nous avons la ^_^séquence qui décide du chemin à suivre en fonction de l'entrée de l'utilisateur. Si 0 , nous allons directement à la séquence de sortie ( >:#,_) en écrivant la fausse chaîne. Si 1 , nous exécutons d'abord >_ce qui efface la première chaîne de la pile, et sortons donc la vraie chaîne.

5 langues, 249 octets

Remarque: les caractères \ret \esont des sauts de ligne et des caractères d'échappement, mais \x5bdoivent être tels quels, sinon Ruby se plaint de la classe de caractères dans l'expression régulière.

Un peu tard pour la fête, et pas du tout un gagnant, mais j'ai commencé à travailler sur un polyglotte pour le défi d'action de grâce et j'ai senti qu'il pourrait être un peu tard, alors je l'ai transformé en ceci!

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

Explication

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

Nous avons mis ici qà ce 0//1qui est 0, nous avons une '''chaîne qui contient la plupart des autres codes, stocker un tableau contenant Falseet Trueet indicies 0et 1respectivement attribuer l'entrée b(qui devrait être 0ou 1pour signifier Falsyet Truthy) , puis printl' be indice a, montrant Falseou True.

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

Comme avec le script Python, nous définissons la variable q, mais dans Ruby, elle est définie sur 0 / /1;'''<?die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));?>/.to_s.ord, car Ruby le décompose 0/en "zéro divisé par" et le suivant /en "début de littéral regex". En utilisant ce littéral, je peux cacher le code PHP et commencer celui de Python '''. Nous devons ajouter .to_s.ordparce que l'opérande droit /doit être a Fixnum. Après cela, nous définissons une fonction input()et la variable Trueet Falsepour contenir leurs homologues français et enfin commencer une chaîne 'qui continue sur la ligne suivante. Enfin , nous créons un tableau aqui contient "Vrai"et "Faux"et les sélectionner à l' aide du input()numéro ed 0ou 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])

En Perl, les q=..=, q+...+et les q-...-blocs sont cités littéraux à l' aide délimiteurs inhabituelles, dans le code ci - dessus , je l' ai remplaçons par '...'. La plupart du code est contenu dans une chaîne littérale, mais nous définissons sub a(qui contient un <><!) Qui vérifie si STDINest inférieur à 1, en retournant soit Waarou Vals. Le print(a[b])fait printest le résultat de l' appel le sub aavec et argument [b]qui est un arrayref qui contient le mot nu 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 première ligne est principalement commentée par la division 0//1( //c'est le commentaire de ligne en JavaScript), nous avons donc juste mis qà 0. La ligne suivante traite de la mise en correspondance des fonctions JS avec leurs noms Python et la définition de variables Trueet Falsed'être les chaînes italiennes.Enfin, nous exécutons la même chose que le code Ruby, en définissant a sur un tableau de mots italiens et en sélectionnant en utilisant un inputde 0ou 1.

PHP: Ekte/Falsk

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

Étant donné que PHP exécute uniquement le code entre <?...?>tout le reste est sorti tel quel, notre code ici imprime simplement un saut de ligne (pour nous remettre au début de la ligne actuelle) et la séquence d'échappement ANSI pour effacer jusqu'à la fin du courant ligne, suivie de Ekteou Falskselon que le caractère d'entrée ( 0ou 1) est vrai ou faux.

Pyth, Python - 28 octets

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

C #, Java, 104 octets

Golfé:

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

Non golfé:

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

Tester:

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

Explication:

Lors de l'appel ToString()ou toString()d'un booléen en C # et Java respectivement, C # imprime la chaîne avec une première lettre majuscule, Trueet False, mais Java imprime tout en minuscules trueet false.

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

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

2 langues, 60 octets

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

Les langues sont:

• Gelée true false
• Python3 waar onwaar

Remarque: il y a des octets UTF-8, pas des octets Jelly.

Lua / JavaScript, 68 octets

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

Je ne sais pas pourquoi je l'ai joué au golf; J'en avais juste envie.

JavaScript / BF

Dans ces deux langues, aucune entrée n'est considérée comme fausse et toute entrée est considérée comme vraie.

Lorsque vous voyez la structure du programme pivotée de 90 degrés vers la gauche, les symboles BF ressemblent à des tours dans une ville :)

Essayez-le en ligne (BF true testcase)!

Essayez-le en ligne (faux test BF)!

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

Explication

Javascript

Si le promptest vrai (c'est-à-dire non vide car promptrenvoie une chaîne), des sorties trueou bien des sorties false.

BF

Sorties sand(danois pour true) s'il y a une entrée, ou bien sorties usand(false) si l'entrée est vide.

TL; DR Si l'entrée n'est pas vide (c'est-à-dire vrai), ne sortez rien. Si l'entrée est vide (c'est-à-dire faux), la sortie u. Ensuite, que l'entrée soit vraie ou fausse, sortez sand.

Je me suis inspiré de https://esolangs.org/wiki/Brainfuck_algorithms avec lequel j'ai construit la logique de mon programme.

Prenez votre avis. Si l'entrée n'est pas vide, incrémentez la mémoire, appelons cette cellule "Cellule A". Fin de l'instruction if

>
,[
>+
<<
]>

Compare la valeur de "Cellule A" avec 0. S'ils sont égaux, que "Cell B" soit 1, ou bien que ce soit 0.

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

Si "Cell B" est 1, alors sortez u. Fermer l'instruction if

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

Production sand

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

Haskell, JavaScript, Python, 115 octets

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+[]//"""#-}