Después de toda la diversión que hemos tenido con los desafíos políglotas en el pasado ( reciente ), ¿qué tal un desafío donde la salida puede estar en dos idiomas?

Su respuesta debe aceptar la entrada booleana by la salida del texto "true"o "false". El mismo código de salida tiene que, cuando se ejecuta en otro idioma, "waar"o "onwaar", o cualquier otra traducción de truey false.

Entrada

• La entrada es una verdad / falsey claramente distinguible. Se admiten los valores reales T / F, un bit, int o cadena (vacía).
• La entrada debe ser la misma para todas las partes de su envío.

Salida

• La salida puede ser devuelta por una función, escrita STDOUT, colocada en una ventana emergente, impresa en 3D y enviada por correo, etc.

• La salida necesita representar el estado de b. Por lo tanto, un 'verdadero' debe generar 'verdadero', 'waar' ... y 'falsey' debería conducir a 'falso', 'onwaar', etc.

• Diferentes idiomas pueden usar diferentes métodos de salida.

Idiomas utilizados

• Una de sus salidas DEBE ser "true"y "false".

• Las diferentes versiones de lenguajes de programación cuentan como lenguajes diferentes para este desafío.

• Los diferentes dialectos de un lenguaje humano cuentan como idiomas diferentes para este desafío.

• Puede extender el políglota a más de dos lenguajes de programación. Cada lenguaje de programación necesita generar un lenguaje humano distinto.

La respuesta con la mayoría de los idiomas incorporados será declarada ganadora. Cuando está empatado, se considera bytecount.

Dyalog APL , 243 237 bytes : 14 idiomas, ampliable a 131 *

-6 bytes gracias a Soaku .

Requiere ⎕IO←0cuál es el predeterminado en muchos sistemas. Solicita la entrada de 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'

Dependiendo de la versión (9.0 a 16.0, con versiones menores) sale en inglés, español, portugués, alemán, vietnamita, francés, turco, italiano, polaco, sundanés, filipino, yoruba, uzbeco o rumano, aunque sin diacríticos.

 ⎕AV⍳'ëáàÆÅÄòðÓÈÇ'en los índices de la A tomic V ector (151 142 141 133 132 131 122 121 111 102 101 96)

((... )⍳... )encuentra la posición de

 ⍎ el evaluado

 ⎕D∩⍨intersección de D igits y

 4↑ los cuatro * primeros caracteres de

 1⊃ el segundo elemento de

 #⎕WG'APLVersion' el número de versión

(... )⊃luego usa eso para elegir

⎕⊃ el elemento input'th (0: primero; 1: segundo) de

s¨la función s (que definiremos en breve) aplicada a cada uno de

⌽ el reverso de

(s←{... }) s aplicado a - donde s se define como

 1↓¨ el primer personaje caído de cada uno de

 ⍵⊂⍨ el argumento dividido donde

 ⍵= los caracteres del argumento son iguales a

 ⊃⍵ el primer personaje del argumento

';,true,adevarat,... ,falsch',esta cadena antepuso a

18⍴',falso' dieciocho caracteres tomados cíclicamente de esa cadena

* Desde la versión 12.1, el número de versión incluye el número de compilación, por lo que al aumentar el número de caracteres tomados de esta cadena, es fácil cubrir los 131 idiomas de escritura latina .

6 idiomas, 169 bytes

Espera 0\no 1\ncomo entrada, e imprime palabras en:

• Python 2 (holandés vals/waar),
• Python 3 (francés faux/vrai),
• Ruby (inglés false/true)
• CJam (noruego usant/sant),
• Golfscript (danés 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",,,,,@

Todos los Funges, 6 idiomas, 146 bytes.

💥 ¡Ahora en 3D! 💥

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

Para mayor claridad, he separado los dos planos de código para que pueda ver cómo están en capas. En el disco, estos dos bloques se separarían con un carácter de avance de formulario al final de la línea anterior.

   h"vals"0"waar"<

Las reglas decían que las diferentes versiones de un idioma cuentan como idiomas separados, por lo que esta es seis versiones de Funge / Befunge. :)

• Befunge-93 (español - cierto / falso) ¡ Pruébelo en línea!
• Befunge-96 (latín - verum / falsum) ¡ Pruébelo en línea!
• Befunge-97 (francés - vrai / faux) ¡ Pruébelo en línea!
• Befunge-98 (Inglés - verdadero / falso) ¡ Pruébelo en línea!
• Unefunge-98 (noruego - ekte / falsk)
• Trefunge-98 (holandés - waar / vals)

Gracias a Dennis , todas las versiones de Befunge ahora se pueden probar en línea en TIO . Sin embargo, actualmente no hay implementaciones que funcionen de las variantes Unefunge y Trefunge, por lo que para aquellos que recomendaría Rc / Funge .

Ase ignora en Befunge 93 y 96, pero es el comando Acerca de la cara en 97 y no se admite en 98 y, por lo tanto, se refleja. Esto significa que 93 y 96 siguen a la vbaja mientras que 97 y 98 se envuelven al lado opuesto del campo de juego.

En Befunge 96, un ;espacio seguido al comienzo de la línea lo marca como un comentario, de modo que esa línea se omite y el intérprete continúa >en la tercera línea. En 93, sin embargo, el intérprete sigue el >de la segunda línea.

La ruta 97/98 continúa en la primera línea de derecha a izquierda, saltando sobre la sección dentro de los ;marcadores de comentarios, une el &comando y finalmente llega a la secuencia de U-bend v<^<. En Unefunge, estos cambios de dirección no son compatibles, por lo que el intérprete invierte la dirección y ejecuta la sección omitida anteriormente en los comentarios. En Befunge / Trefunge continúa hacia la izquierda.

En Befunge 97, el mcomando no es compatible y, por lo tanto, se omite, por lo que el intérprete continúa a lo largo de la primera línea. En 98 es solo en 3D, por lo que se refleja en Befunge (2D) y el intérprete sigue va la derecha de la misma hasta la cuarta línea. En Trefunge (3D) es una rama alta-baja que transfiere un nivel a lo largo del eje z al segundo plano.

Entonces, aparte del caso Unefunge, tenemos cada versión reuniendo su par de cadenas desde una línea separada antes de ser dirigido a uno de los &comandos para obtener la entrada del usuario. Esas rutas de código se fusionan a través de los ^comandos en la segunda columna, dirigiendo el flujo del programa hacia arriba a través de la parte superior del campo de juego, volviendo a la parte inferior nuevamente.

Finalmente tenemos la ^_^secuencia que decide qué camino seguir en función de la entrada del usuario. Si es 0 , vamos directamente a la secuencia de salida ( >:#,_) escribiendo la cadena falsa . Si es 1 , primero ejecutamos lo >_que borra la primera cadena de la pila y, por lo tanto, genera la cadena verdadera .

5 idiomas, 249 bytes

Nota: los \ry \eson caracteres de salto de línea y de salto de línea literales, pero \x5btiene que ser como es, de lo contrario, Ruby se queja de la clase de caracteres en la expresión regular.

Llegué un poco tarde a la fiesta, y no soy un ganador de ninguna manera, pero comencé a trabajar en un políglota para el desafío de acción de gracias y sentí que podría ser un poco tarde, ¡así que lo transformé en esto!

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

Explicación

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

Aquí establecemos qa 0//1que es 0, entonces tenemos una '''cadena que contiene la mayor parte del otro código, almacenar una matriz que contiene Falsey Truey indicies 0y 1respectivamente, asignar la entrada a b(que debe ser 0o 1para significar Falsyy Truthy), entonces printla bésimo índice de a, mostrando Falseo 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])

Al igual que con la secuencia de comandos de Python, establecemos la variable q, pero en Ruby esto se establece en 0 / /1;'''<?die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));?>/.to_s.ord, ya que Ruby divide esto 0/como "cero dividido por" y lo siguiente /como "comienzo del literal regex". Usando este literal, puedo ocultar el código PHP y comenzar Python '''. Tenemos que agregar .to_s.ordporque el operando correcto /tiene que ser a Fixnum. Después de esto definimos una función input()y la variable Truey Falsepara contener sus homólogos franceses y, finalmente, empezamos una cadena 'que continúa en la línea siguiente. Por último, creamos una matriz aque contiene "Vrai"y "Faux"y seleccionarlas con el input()número 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])

En Perl, los bloques q=..=, q+...+y q-...-, son literales entre comillas usando delimitadores inusuales, en el código anterior los he reemplazado por '...'. La mayor parte del código está contenido en una cadena literal, pero definimos sub a(¡que contiene un <><!) Que verifica si STDINes menor que 1, devolviendo Waaro Vals. En print(a[b])realidad, printes el resultado de llamar al sub awith y al argumento de los [b]cuales es un ArrayRef que contiene la palabra desnuda 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 primera línea se comenta en su mayoría a cabo por la división 0//1( //es comentario de línea en JavaScript) así que sólo pusimos qa 0. La siguiente línea trata de asignar las funciones JS a sus nombres de Python y variables de configuración Truey Falseser las cadenas italianas, finalmente ejecutamos lo mismo que el código Ruby, configurando a una matriz de palabras italianas y seleccionando usando un inputde 0o 1.

PHP: Ekte/Falsk

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

Dado que PHP solo ejecuta el código entre <?...?>todo lo demás, se genera tal como está, por lo que nuestro código aquí simplemente imprime un avance de línea (para volver al comienzo de la línea actual) y la secuencia de escape ANSI para borrar hasta el final de la corriente línea, seguida de Ekteo Falskdependiendo de si el carácter de entrada ( 0o 1) es verdadero o falso.

Pyth, Python - 28 bytes

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

C #, Java, 104 bytes

Golfizado:

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

Sin golf:

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

Prueba:

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

Explicación:

Al llamar ToString()o toString()en un booleano en C # y Java respectivamente, C # imprime la cadena con una primera letra mayúscula Truey False, pero Java imprime todo en minúsculas truey false.

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

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

2 idiomas, 60 bytes

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

Los idiomas son:

• Jalea true false
• Python3 waar onwaar

Nota: Hay bytes UTF-8, no bytes Jelly.

Lua / JavaScript, 68 bytes

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

No sé por qué lo jugué; Simplemente me dio la gana.

JavaScript / BF

En ambos idiomas, ninguna entrada se considera falsa y cualquier entrada se considera verdadera.

Cuando vea que la estructura del programa gira 90 grados hacia la izquierda, los símbolos BF parecen torres en una ciudad :)

Pruébelo en línea (BF verdadero caso de prueba)!

¡Pruébelo en línea (BF falso testcase)!

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

Explicación

JavaScript

Si el promptes verdad (es decir, no vacío porque promptdevuelve una cadena), salidas trueo salidas demás false.

BF

Salidas sand(danés para verdadero) si hay una entrada, o bien salidas usand(falso) si la entrada está vacía.

TL; DR Si la entrada no está vacía (es decir, verdadera), no envíe nada. Si la entrada está vacía (es decir, falsa), la salida u. Luego, independientemente de si la entrada es verdadera o falsa, la salida sand.

Me inspiré en https://esolangs.org/wiki/Brainfuck_algorithms con el que construí la lógica de mi programa.

Tomar entrada. Si la entrada no está vacía, incremente la memoria, llamemos a esta celda "Celda A". Fin de la declaración if

>
,[
>+
<<
]>

Compara el valor de "Celda A" con 0. Si son iguales, deja que sea "Celda B" 1, o deja que sea 0.

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

Si "Cell B" es 1, entonces la salida u. Cierre la declaración if

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

Salida sand

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

Haskell, JavaScript, Python, 115 bytes

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