Depois de toda a diversão que tivemos com os desafios poliglotas no passado ( recente ), que tal um desafio em que a saída possa estar em dois idiomas?

Sua resposta precisa aceitar entrada booleana be gerar o texto "true"ou "false". O mesmo código precisa de saída, quando executado em outro idioma, "waar"ou "onwaar"ou qualquer outra tradução de truee false.

Entrada

• A entrada é uma verdade / falsey claramente distinguível. Admissíveis são os valores reais T / F, um bit, int ou string (vazia).
• A entrada precisa ser a mesma para todas as partes do seu envio.

Resultado

• A saída pode ser retornada por uma função, gravada STDOUT, colocada em uma janela pop-up, impressa em 3D e enviada por correio etc.

• A saída precisa representar o estado de b. Portanto, um 'verdadeiro' precisa produzir 'verdadeiro', 'waar' ... e 'falsey' deve levar a 'falso', 'onwaar' etc.

• Idiomas diferentes podem usar métodos de saída diferentes.

Línguas utilizadas

• Uma de suas saídas DEVE ser "true"e "false".

• Versões diferentes de linguagens de programação contam como linguagens diferentes para esse desafio.

• Dialetos diferentes de uma língua humana contam como línguas diferentes para esse desafio.

• Você pode estender o poliglota para mais de duas linguagens de programação. Toda linguagem de programação precisa produzir uma linguagem humana distinta.

A resposta com mais idiomas incorporados será declarada a vencedora. Quando empatado, o bytecount é considerado.

Dyalog APL , 243 237 bytes : 14 idiomas, extensível a 131 *

-6 bytes graças a Soaku .

Requer ⎕IO←0qual é o padrão em muitos sistemas. Solicita a inserção de 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'

Dependendo da versão (9.0 a 16.0, com versões secundárias), ela é impressa em inglês, espanhol, português, alemão, vietnamita, francês, turco, italiano, polonês, sundanês, filipino, ioruba, uzbeque ou romeno, embora sem sinais diacríticos.

 ⎕AV⍳'ëáàÆÅÄòðÓÈÇ'em que os índices da Um Tomic V ector (151 142 141 133 131 122 121 132 111 102 101 96)

((... )⍳... )encontre a posição de

 ⍎ o avaliado

 ⎕D∩⍨interseção de D igits e

 4↑ os quatro * primeiros caracteres de

 1⊃ o segundo elemento de

 #⎕WG'APLVersion' o número da versão

(... )⊃então use isso para escolher entre

⎕⊃ o elemento input'th (0: primeiro; 1: segundo) de

s¨a função s (que definiremos em breve) aplicada a cada um

⌽ o inverso de

(s←{... }) s aplicado a - onde s é definido como

 1↓¨ o primeiro caractere caiu de cada um

 ⍵⊂⍨ o argumento particionou onde

 ⍵= os caracteres do argumento são iguais a

 ⊃⍵ o primeiro caractere do argumento

';,true,adevarat,... ,falsch',essa sequência anexada a

18⍴',falso' dezoito caracteres retirados ciclicamente dessa sequência

* Desde a versão 12.1, o número da versão inclui o número da compilação; portanto, aumentando o número de caracteres extraídos dessa sequência, é fácil cobrir todos os 131 idiomas de script latinos .

6 idiomas, 169 bytes

Espera 0\nou 1\ncomo entrada e imprime palavras em:

• Python 2 (holandês vals/waar),
• Python 3 (francês faux/vrai),
• Ruby (inglês false/true),
• CJam (norueguês usant/sant),
• Golfscript (dinamarquê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 os Fungos, 6 idiomas, 146 bytes

💥 Agora em 3D! 💥

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

Para maior clareza, separei os dois planos de código para que você possa ver como eles estão em camadas. No disco, esses dois blocos seriam separados com um caractere de alimentação de formulário no final da linha acima.

   h"vals"0"waar"<

As regras diziam que versões diferentes de um idioma contam como idiomas separados, então essa é seis versões do Funge / Befunge. :)

• Befunge-93 (espanhol - cierto / falso) Experimente online!
• Befunge-96 (latino - verum / falsum) Experimente online!
• Befunge-97 (Francês - vrai / faux) Experimente online!
• Befunge-98 (inglês - verdadeiro / falso) Experimente online!
• Unefunge-98 (norueguês - ekte / falsk)
• Trefunge-98 (holandês - waar / vals)

Graças a Dennis , todas as versões do Befunge agora podem ser testadas on-line no TIO . No momento, não existem implementações em funcionamento das variantes Unefunge e Trefunge, portanto, para aquelas que eu recomendaria Rc / Funge .

Aé ignorado no Befunge 93 e 96, mas é o comando Sobre o rosto em 97 e não é suportado em 98 e, portanto, reflete. Isso significa que 93 e 96 seguem vpara baixo, enquanto 97 e 98 envolvem o lado oposto do campo de jogo.

No Befunge 96, um ;espaço seguido no início da linha o marca como um comentário, para que a linha seja ignorada e o intérprete continue >na terceira linha. Em 93, porém, o intérprete segue o >da segunda linha.

O caminho 97/98 continua na primeira linha da direita para a esquerda, passando por cima da seção dentro dos ;marcadores do comentário, pontes o &comando, acabou atingindo a seqüência U-bend v<^<. No Unefunge, essas mudanças de direção não são suportadas; portanto, o intérprete inverte a direção e executa a seção anteriormente ignorada nos comentários. Em Befunge / Trefunge, continua para a esquerda.

No Befunge 97, o mcomando não é suportado e, portanto, é ignorado; portanto, o intérprete continua na primeira linha. Em 98, é apenas 3D, portanto reflete em Befunge (2D) e o intérprete segue và direita até a quarta linha. No Trefunge (3D), é um ramo Alto-Baixo que transfere um nível ao longo do eixo z para o segundo plano.

Portanto, além do caso Unefunge, cada versão reúne seu par de strings de uma linha separada antes de ser direcionada a um dos &comandos para obter a entrada do usuário. Esses caminhos de código então todos se fundem por meio dos ^comandos da segunda coluna, direcionando o fluxo do programa para cima através do topo do campo de jogo, passando para o fundo novamente.

Finalmente, temos a ^_^sequência que decide qual caminho seguir com base na entrada do usuário. Se 0 , vamos direto para a sequência de saída ( >:#,_) escrevendo a string falsa . Se 1 , primeiro executamos o >_que limpa a primeira string da pilha e, assim, produz a string verdadeira .

5 idiomas, 249 bytes

Nota: o \re \esão literais caracteres de linha de alimentação e de escape, mas \x5btem que ser como é caso contrário Rubi reclama da classe de caracteres na expressão regular.

Um pouco atrasado para a festa, e não um vencedor de forma alguma, mas comecei a trabalhar em uma poliglota para o desafio de ação de graças e senti que poderia ser um pouco tarde, então transformou-a nisso!

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

Explicação

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

Aqui nós definir qa 0//1qual é 0, em seguida, que tem uma '''cadeia que contém a maior parte do outro código, armazenar uma matriz contendo Falsee Truee indicies 0e 1, respectivamente, atribuir a entrada para b(que deve ser 0ou 1para significar Falsye Truthy) em seguida, printo bíndice de po de a, mostrando Falseou 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])

Assim como no script Python, definimos a variável q, mas no Ruby isso é definido 0 / /1;'''<?die("\r\e\x5bK".(fgetc(STDIN)?Ekte:Falsk));?>/.to_s.ordcomo, pois o Ruby divide isso 0/como "zero dividido por" e o seguinte /como "início do regex literal". Usando esse literal, sou capaz de ocultar o código PHP e começar o Python '''. Temos que adicionar .to_s.ordporque o operando certo /deve ser a Fixnum. Depois disso, definimos uma função input()e a variável Truee Falsepara conter seus equivalentes franceses e, finalmente, iniciamos uma string 'que continua na próxima linha. Finalmente, criar uma matriz aque contém "Vrai"e "Faux"e seleccioná-las utilizando o input()número 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])

No Perl, os blocos q=..=, q+...+e q-...-são citados literais usando delimitadores incomuns, no código acima, eu os substituí por '...'. A maior parte do código está contida em uma string literal, mas definimos sub a(que contém um <><!) Que verifica se STDINé menor que 1, retornando Waarou Vals. Na print(a[b])verdade, printé o resultado da chamada de sub awith e argumento, [b]que é um ArrayRef que contém a palavra simples 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])

A primeira linha é principalmente comentada pela divisão 0//1( //é o comentário da linha em JavaScript), então definimos qcomo 0. A próxima linha lida com o mapeamento das funções JS para seus nomes Python e para definir variáveis Truee Falsepara ser as seqüências italianas; finalmente, executamos o mesmo que o código Ruby, configurando a para uma matriz de palavras italianas e selecionando usando um inputde 0ou 1.

PHP: Ekte/Falsk

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

Como o PHP executa apenas o código entre <?...?>tudo o que é produzido, o código aqui simplesmente imprime um feed de linha (para nos colocar de volta no início da linha atual) e a seqüência de escape ANSI para limpar até o final da atual linha, seguida por um Ekteou Falskdependendo de o caractere de entrada ( 0ou 1) ser verdadeiro ou falso.

Pyth, Python - 28 bytes

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

C #, Java, 104 bytes

Golfe:

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

Teste:

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

Explicação:

Ao chamar ToString()ou toString()em um booleano em C # e Java, respectivamente, o C # imprime a string com uma primeira letra maiúscula Truee False, mas Java imprime tudo em letras minúsculas truee false.

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

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

2 idiomas, 60 bytes

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

Os idiomas são:

• Geléia true false
• Python3 waar onwaar

Nota: Existem bytes UTF-8, não bytes Jelly.

Lua / JavaScript, 68 bytes

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

Não sei por que eu jogava golfe; Eu apenas senti vontade.

JavaScript / BF

Nos dois idiomas, nenhuma entrada é considerada falsa e qualquer entrada é considerada verdadeira.

Quando você vê a estrutura do programa girada 90 graus para a esquerda, os símbolos BF parecem torres em uma cidade :)

Experimente on-line (BF true testcase)!

Experimente online (BF false testcase)!

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

Explicação

Javascript

Se promptfor verdadeiro (ou seja, não estiver vazio porque promptretorna uma string), sai true, ou então sai false.

BF

Saídas sand(dinamarquês para true) se houver uma entrada ou saídas usand(false) se a entrada estiver vazia.

TL; DR Se a entrada não estiver vazia (ou seja, verdadeira), não produza nada. Se a entrada estiver vazia (ou seja, falsa), faça a saída u. Então, independentemente de a entrada ser verdadeira ou falsa, imprima sand.

Eu me inspirei em https://esolangs.org/wiki/Brainfuck_algorithms com o qual construí a lógica do meu programa.

Tome entrada. Se a entrada não estiver vazia, aumente a memória, vamos chamar esta célula "Célula A". Terminar declaração if

>
,[
>+
<<
]>

Compara o valor da "Célula A" com 0. Se forem iguais, deixe a "Célula B" ser 1, ou então seja 0.

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

Se "Célula B" for 1, então faça a saída u. Fechar instrução if

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

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