Tarefa

Crie um programa ou uma função que seja válida em várias linguagens de programação e, quando compilada / interpretada como uma linguagem diferente, produz "Olá, Mundo!" em uma linguagem natural diferente.

Por exemplo, uma solução válida pode produzir Hello World!(inglês) quando compilado e executado como C, Hallo Welt!(alemão) quando compilado e executado como C ++ e 你好世界！(chinês) quando executado como Python.

Regras

Para evitar ambiguidade sobre a validade de uma resposta, abaixo está uma lista de versões permitidas da frase em vários idiomas. A lista consiste na frase nos idiomas para os quais o Google Translate possui uma tradução verificada pela comunidade (até o momento em que este artigo foi escrito). *

A precisão dessas traduções é discutível, mas elas são o que esse desafio usará. As seqüências impressas devem seguir exatamente o formato abaixo (com exceção dos espaços em branco à esquerda ou à direita).

Afrikaans:    Hello Wêreld!
Albanian:     Përshendetje Botë!
Amharic:      ሰላም ልዑል!
Arabic:       مرحبا بالعالم!
Armenian:     Բարեւ աշխարհ!
Basque:       Kaixo Mundua!
Belarussian:  Прывітанне Сусвет!
Bengali:      ওহে বিশ্ব!
Bulgarian:    Здравей свят!
Catalan:      Hola món!
Chichewa:     Moni Dziko Lapansi!
Chinese:      你好世界！
Croatian:     Pozdrav svijete!
Czech:        Ahoj světe!
Danish:       Hej Verden!
Dutch:        Hallo Wereld!
English:      Hello World!
Estonian:     Tere maailm!
Finnish:      Hei maailma!
French:       Bonjour monde!
Frisian:      Hallo wrâld!
Georgian:     გამარჯობა მსოფლიო!
German:       Hallo Welt!
Greek:        Γειά σου Κόσμε!
Hausa:        Sannu Duniya!
Hebrew:       שלום עולם!
Hindi:        नमस्ते दुनिया!
Hungarian:    Helló Világ!
Icelandic:    Halló heimur!
Igbo:         Ndewo Ụwa!
Indonesian:   Halo Dunia!
Italian:      Ciao mondo!
Japanese:     こんにちは世界！
Kazakh:       Сәлем Әлем!
Khmer:        សួស្តី​ពិភពលោក!
Kyrgyz:       Салам дүйнө!
Lao:          ສະ​ບາຍ​ດີ​ຊາວ​ໂລກ!
Latvian:      Sveika pasaule!
Lithuanian:   Labas pasauli!
Luxemburgish: Moien Welt!
Macedonian:   Здраво свету!
Malay:        Hai dunia!
Malayalam:    ഹലോ വേൾഡ്!
Mongolian:    Сайн уу дэлхий!
Myanmar:      မင်္ဂလာပါကမ္ဘာလောက!
Nepali:       नमस्कार संसार!
Norwegian:    Hei Verden!
Pashto:       سلام نړی!
Persian:      سلام دنیا!
Polish:       Witaj świecie!
Portuguese:   Olá Mundo!
Punjabi:      ਸਤਿ ਸ੍ਰੀ ਅਕਾਲ ਦੁਨਿਆ!
Romanian:     Salut Lume!
Russian:      Привет мир!
Scots Gaelic: Hàlo a Shaoghail!
Serbian:      Здраво Свете!
Sesotho:      Lefatše Lumela!
Sinhala:      හෙලෝ වර්ල්ඩ්!
Slovenian:    Pozdravljen svet!
Spanish:      ¡Hola Mundo!         // Leading '¡' optional
Sundanese:    Halo Dunya!
Swahili:      Salamu Dunia!
Swedish:      Hej världen!
Tajik:        Салом Ҷаҳон!
Thai:         สวัสดีชาวโลก!
Turkish:      Selam Dünya!
Ukrainian:    Привіт Світ!
Uzbek:        Salom Dunyo!
Vietnamese:   Chào thế giới!
Welsh:        Helo Byd!
Xhosa:        Molo Lizwe!
Yiddish:      העלא וועלט!
Yoruba:       Mo ki O Ile Aiye!
Zulu:         Sawubona Mhlaba!

Portanto, existem 74 idiomas que podem ser usados.

Critério vencedor

A solução que pode gerar a frase no maior número de idiomas vence. Em caso de empate, a solução mais curta (em bytes) vence.

_{* As traduções para malgaxe e maltês foram marcadas como verificadas pela comunidade, mas estavam claramente incorretas (uma era apenas "Hello World!" E a outra "Hello dinja!", Mas apenas "Hello!" Se traduz em "Bongu!"). Estes foram excluídos. Além disso, alguns idiomas (árabe, hebraico, pashto, persa e ídiche) são lidos da direita para a esquerda no Google Translate, mas, quando copiados aqui, são lidos da esquerda para a direita. Espero que esteja tudo bem.}

23 bits, 713 bytes

A única linguagem que eu realmente sei é o Befunge, então, em vez de vários idiomas, acabei de usar várias implementações do Befunge. Eu acredito que isso ainda é válido sob as regras do PPCG, que consideram o idioma a ser definido por sua implementação .

8023/# !-1401p680p88+79*6+1p238*7+0pg90p$#v0';1';+>9%80p$$$$"ph~s"+3vv
vv_2#!>#-/\#21#:+#:>#\<0/-2*3`0:-/2g01g00p>#< 2#0 ^#1/4*:*9"9"p00***<<
>>$:2%3*-4/3g68*-70p1-0`02-3/-03-2%1+2/-70g+80g65+70g`7++3g68*-70g9`*v
0168:0>0133?45130120340200v00:<+8*+76%4p00+5/4:+-*86g3++98/2%+98g09+<<
                         @>gg#^:#+,#$"!"-#1_@
       !Helo Byd!!!!!Hai dunia!!!!Ciao mondo!!!Hallo Wereld!!!!
       !Hallo Welt!!!Halo Dunia!!!Halo Dunya!!!Bonjour monde!!!
       !Hei Verden!!!Hej Verden!!!Moien Welt!!!Labas pasauli!!!
       !Molo Lizwe!!!Salut Lume!!!Hei maailma!!Sveika pasaule!!
       !Hello World!!Salom Dunyo!!Tere maailm!!Sawubona Mhlaba!
       !Kaixo Mundua!Salamu Dunia!Sannu Duniya!!!!!!!!!!!!!!!!!

O que é frustrante no Befunge é que, embora exista uma implementação de referência de código aberto e a própria linguagem seja simples, não há um único intérprete de terceiros (que eu saiba) que corresponda exatamente ao comportamento de referência. Toda implementação falha de uma maneira diferente.

No lado positivo, isso nos dá a oportunidade de desenvolver um único pedaço de código que produzirá um resultado diferente em quase todos os intérpretes. E é isso que estou tentando no programa acima.

Se alguém estiver interessado em verificar os resultados, tentei agrupar as várias implementações em categorias com base na facilidade de instalação e funcionamento (por exemplo, algumas pessoas podem não conseguir executar os binários do Windows ou podem não estar dispostas a construir a partir da fonte, mas todos devem poder testar os intérpretes on-line).

Intérpretes Online

Nenhuma instalação é necessária. Geralmente, basta colar o código e clicar em um ou dois botões. Mas observe que alguns deles são bastante lentos, por isso pode levar algum tempo para concluir a execução.

Clique no Clear...botão e cole o código no campo de entrada. Alterne Editpara ativar o intérprete e clique no Runbotão para começar a executar.
Observe que este site provavelmente não funcionará no navegador que não seja o Chrome.

Cole o código no campo de entrada, substituindo o código existente. Em seguida, clique no Runbotão para executar.

Cole o código no campo de entrada Playfield e clique no Runbotão para começar a executar.

Cole o código no campo de entrada abaixo do Showbotão, certificando-se de substituir o @que já está lá. Clique no Showbotão para importar o código e clique no Runbotão para começar a executar.

Primeiro feche a caixa de diálogo Ajuda , clique no botão Abrir / Importar da barra de ferramentas (segundo da esquerda), cole o código e clique em OK. Para executar, clique no botão Modo de Execução (quarto da esquerda) e, em seguida, Iniciar (quinto da esquerda).

Observe também que alguns dos intérpretes baseados em console estão realmente disponíveis no TIO; portanto, embora não sejam intérpretes tecnicamente online, eles podem ser testados online. Para aqueles que são suportados (atualmente BEF, FBBI, MTFI e PyFunge), incluí um Try It Online! ao lado da entrada deles.

IDEs Java

Você precisará ter o tempo de execução do Java instalado para eles, mas eles teoricamente devem funcionar em qualquer plataforma. Apenas testado no Windows.

Inicialmente, era um applet online que, infelizmente, não está mais disponível, mas você ainda pode fazer o download do jar e executá-lo localmente como um aplicativo de desktop. Você precisará colar o código na janela do Editor de Programas e clicar no Convertbotão, seguido pelo Runbotão.

Para colar o código, clique com o botão direito do mouse no canto superior esquerdo da janela do editor (ele deve estar no canto superior esquerdo) e selecione o item de menu Colar . Em seguida, ative a caixa de seleção Velocidade total (caso contrário, levará uma eternidade) e clique no Run!botão para começar a executar.

Pressione Ctrl+ A, Ctrl+ Vpara colar o código na janela do editor, substituindo a fonte padrão. Em seguida, clique no Startbotão para começar a executar.

IDEs do Windows

Você normalmente precisará do Windows para isso, embora em alguns casos possa haver binários disponíveis para outros sistemas operacionais. Não posso prometer que o código funcionará em outras plataformas.

Como você não pode colar o código no editor, primeiro precisará salvá-lo em disco em algum lugar. Em seguida, no IDE, use o menu Arquivo> Abrir para carregar o código do disco e selecione o menu Simulação> Executar / Pausar para executá-lo.

Pressione Ctrl+ Vpara colar o código e clique no botão Debug da barra de ferramentas (a engrenagem azul) para começar a execução. Quando o painel Debugger aparecer, você desejará definir a velocidade no máximo - o botão à direita do controle deslizante - caso contrário, levará uma eternidade para terminar.

Pressione Ctrl+ Vpara colar o código e pressione F5para executá-lo.

Como você não pode colar o código no editor, primeiro precisará salvá-lo em disco em algum lugar. Em seguida, no IDE, pressione Ctrl+ Opara abrir o navegador de arquivos e carregar o código do disco e pressione F5para executá-lo.

Aplicativos de console do Windows

Novamente, eles normalmente exigem Windows, embora outras plataformas possam estar disponíveis, mas não garantidas que funcionem.

Em todos os casos, o código precisará ser salvo em um arquivo no disco e o nome do arquivo passado para o intérprete como um parâmetro da linha de comando ( source.bf nos exemplos de linhas de comando abaixo). Observe também que alguns deles são tecnicamente intérpretes do Befunge-98 e devem ser executados com uma opção de linha de comando específica para forçar um modo de compatibilidade do Befunge-93. Se você não fizer isso, não obterá os resultados corretos.

Linha de comando: bef93w32 -q source.bf

Linha de Comand: ccbi --befunge93 source.bf

Linha de comando: mtfi -3 source.bf( Experimente online! )

Aplicativos de console Python e PHP

Isso requer a linguagem de script apropriada instalada - Python ou PHP.

Linha de comando: befungee.py source.bf

Linha de comando: pyfunge -v 93 source.bf( Experimente online! )

Linha de comando: php bephunge.phps source.bf

Aplicativos de console somente de origem

Eles precisarão ser construídos a partir da fonte, e isso geralmente é mais fácil com um ambiente semelhante ao * nix. No Windows, eu uso o Windows Subsystem for Linux .

Linha de comando: bef -q source.bf( Experimente online! )

Linha de comando: cfunge -s 93 source.bf

Linha de comando: fbbi -93 source.bf( Experimente online! )

Linha de comando: fungi source.bf

Linha de comando: rcfunge -93 source.bf

Como funciona

O desafio foi encontrar o menor número de testes que fornecesse a maior diferenciação entre intérpretes. No final, resumiu-se a quatro principais sequências de teste:

1. A primeira é uma memória fora dos limites lida do deslocamento -1,1. Em teoria, isso sempre deve retornar 32 (espaço ASCII), mas na verdade havia 10 variações na prática. Esse teste é complicado pelo fato de dois dos intérpretes travarem em uma leitura fora dos limites; portanto, foram necessários alguns testes de casos especiais (arredondamento de divisão e ponte de espaço) para forçar esses dois de volta aos limites.

2. A segunda sequência é um teste da funcionalidade Befunge-98 - especificamente as instruções ;e '. Quase todos os intérpretes são o Befunge-93 ou são executados no modo de compatibilidade do Befunge-93, portanto, eles devem simplesmente ignorar essas instruções. Na prática, havia 6 maneiras diferentes pelas quais essa sequência foi interpretada.

3. O terceiro teste verifica o intervalo de células da memória. No intérprete de referência, as células de memória são assinadas com 8 bits, mas outras implementações variam de 8 bits a ilimitadas, algumas assinadas e outras não assinadas. No entanto, para os fins deste teste, tivemos apenas que distinguir entre 5 dessas variantes.

4. A quarta e última sequência é uma combinação de testes de sub-fluxo e de divisão negativa. Existem várias maneiras pelas quais os intérpretes estão errados e há pelo menos três maneiras diferentes pelas quais as instruções de divisão e módulo são implementadas, mas havia apenas três combinações com as quais nos importamos aqui.

Cada uma dessas seqüências retornou um único número e esses quatro números foram combinados (por meio de algumas tabelas aritméticas e de conversão básicas) para produzir um valor final no intervalo de 0 a 22. Esse valor poderia ser usado como um índice para pesquisar a mensagem real mostrar.

16 idiomas, 1363 bytes

 #define ip"MemuL tulaS",,,,,,,,,,"!",@++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.@,kc"Kaixo Mundua!"v#!
#define print(A,B,C)main(){printf("Helo Byd!");}//ss                                                                          ;ooooooooooooooooooo"Moni Dziko Lapansi!"<  
#ifdef __cplusplus//p                                                                                                                                 ;;];;
#include<cstdio>//ffffffffff?
#define print(A,B,C)int main(){printf("Halo Dunya!");}//ssp
#endif//;  [;;;;;;;;;     "!etejivs vardzoP"]
#ifdef __OBJC__//;;;;;
#define print(A,B,C)main(){printf("Hallo Welt!");}//ss
#endif//\
"""echo" "Salom Dunyo!";"exit";puts"Moien Welt!";\
__END__
#define B//\
"""#;;;;;
print(["Hai dunia!","Hej Verden!","Halo Dunia!"][(int(1>0)is 1)+~int(-1/2)*2])
#define s eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeejeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeejiiiiiiiijeeeeeeeeeeeeeejiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiijeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeejeejijiiiiiiiiiijeeeeeeeeeeejiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiij
#define U   !"!dlereW ollaH"<           ;
#define T@,kc"Sannu Duniya!?%?"

Experimente online!

(use "alternar idiomas" para alterar o idioma)

• Python 3 = Halo Dunia! (Indonésio)

• Python 2 = Hej Verden! (Dinamarquês)

• Python 1 = Hai dunia! (Malaio)

• C (gcc) = Helo Byd! (Galês)

• C ++ (gcc) = Halo Dunya! (Sudanês)

• Objetivo C (toque) = Olá, Welt! (Alemão)

• Brainfuck = Olá Mundo! (Inglês obviamente)

• Befunge-93 = Salute Lume! (Romena)

• Ruby = Moien Welt! (Luxemburguês)

• Bash = Salom Dunyo! (Usbeque)

• Befunge-98 (PyFunge) = Kund Mundua! (Basco)

• Unefunge-98 (PyFunge) = Sannu Duniya! (Hausa)

• Cardeal = Olá, Wereld! (Holandês)

• Alphuck = Ciao mondo! (Italiano)

• > <> = Moni Dziko Lapansi! (Chichewa)

• Fissão = Pozdrav svijete! (Croata)

Quaisquer dicas de golfe são bem-vindas (especialmente no Brainfuck) !!

Graças a @ JonathanFrech por -1 byte! Além disso, obrigado a @ovs por -40 bytes!

Como (idéias gerais, eu realmente esqueci detalhes)?

Os idiomas podem ser divididos em quatro grupos:

• Macro: C, C ++, Objetivo C
• Comentário: Python3, Python2, Python1, Ruby, Bash
• Dimensional: Befunge-93, Befunge-98, Unefunge-98, Cardeal,> <>, Fissão
• Vulgar: Brainfuck, Alphuck

As linguagens de macro são vistas #como o início de uma diretiva de pré-processador. Eles são usados ​​por três razões: para abrigar o código de outros grupos, para distinguir entre os idiomas de macro e para definir realmente uma macro. Todos os três são usados //como comentário. Depois disso, armazenamos o código para os outros grupos. Além disso, a barra invertida continua o comentário nesses idiomas.

Os idiomas de comentário são vistos #como o início de um comentário. A peculiaridade aqui são as aspas triplas, que distinguem os Pythons de Ruby e Bash. E para distinguir Python 1 de 2 de 3, usamos um recurso distintivo nos três, juntamente com uma matriz de saídas. Ah sim, também tem isso __END__. Isso é usado para finalizar o código para alguns dos idiomas de Comentário (não consigo lembrar exatamente quais).

As linguagens dimensionais são diferenciadas de uma maneira difícil de explicar. É preciso conhecer as especificidades de cada idioma para descobrir isso. Por exemplo, #é apenas um pulo nos fungeóides, enquanto faz várias coisas diferentes nos outros idiomas. O código está espalhado por toda parte para esses idiomas.

E, finalmente, chegamos às línguas vulgares. Esses dois ignoram tudo o que não está no conjunto de caracteres válidos. Um ato de equilíbrio deve ser executado com esses idiomas e com os outros, pois o código já contém caracteres nos conjuntos de caracteres.

15 idiomas, 532 bytes

# ;"!audnuM oxiaK">:#,_@R"Hej Verden!";;@,kb"Tere maailm!";# w"!amliaam ieH"ck,@oooooooooo"Hai dunia!"
`true #{puts'Hola món!'}` \
__END__
"Hola Mundo!" puts
case `ps -p$$ -oargs=` in \
b*)echo Hallo Welt!;;k*)echo Ndewo Ụwa!;;d*)echo Ciao mondo!;;z*)echo Moien Welt!;;a*)echo Hei Verden!;;esac
true; 
#xx
#x%"Olá Mundo!"x
#xx+++[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.
   	  	   
	
     		  	 	
	
     		 		  
	
     		 				
	
     	     
	
     	    	 
	
     				  	
	
     		  	  
	
     	    	
	
  

Experimente online!

1. Kaixo Mundua! em Befunge-93
2. Hej Verden! em fissão
3. Tere maailm! em Unefunge-98
4. Hei maailma!! em Befunge-98
5. Hai dunia! em> <>
6. Hola món! em Ruby
7. Hola Mundo! no GolfScript
8. Hallo Welt! na festança
9. Ndewo Ụwa! em ksh
10. Ciao mondo! em colisão
11. Moien Welt! em zsh
12. Hei Verden! em cinzas
13. Olá Mundo! no cardeal
14. Hello World!em brainfuck, cortesia de primo .
15. Helo Byd! em espaço em branco

Explicação

A linha 1 distingue entre cinco esolangs 2D:

1. ><>lê #como um espelho, envolve a esquerda, imprime "Hai dunia!"e trava ( @). Todos os Fungos o leem como um trampolim e vão para a direita.
2. O Befunge-93 ignora ;, imprime Kaixo Mundua!e sai ( @).
3. Os Fungos de 98 saltam do primeiro ;para o segundo e depois do terceiro ;para o quarto. wé um NOP para Befunge-98, imprimindo Hei maailma!.
4. Mas wreflete o ponteiro de instruções em Unefunge-98, imprimindo Tere maailm!.
5. A fissão não começa no canto superior esquerdo. R"Hej Verden!";É executado. (Outro ponteiro de instrução começa a partir do Din __END__, mas ele não faz nada e morre no ;in true;.)

Ruby vê `true #{puts'Hola món!'}`, então __END__.

GolfScript vê `, então true(NOP), então um comentário; então __END__(NOP); então "Hola Mundo!" puts(isto é executado); then case(NOP), then `(trava na pilha vazia).

Os shells veem um comentário, depois uma invocação para true(NOP), depois invocações para comandos desconhecidos __END__e "Hola Mundo!"(que erro ocorre no STDERR, mas a execução continua), depois a caseinstrução que distingue com base na primeira letra do nome do processo atual.

O Cardinal é outro esolang 2D que começa no %, enviando 4 IPs para cima, baixo, esquerda e direita. Todos são mortos pelos xcomandos ao redor , mas um imprime "Olá Mundo!"antes de morrer.

O código brainfuck é primo, prefixado com ++para combater os traços ps -p$$ -oargs=.

O espaço em branco no meu código é executado como o programa Whitespace

 push 0
 push 0
label_0:
 push 0
 push 0
 drop
 drop
 push 72; printc
 push 101; printc
 push 108; printc
 push 111; printc
 push 32; printc
 push 66; printc
 push 121; printc
 push 100; printc
 push 33; printc

que imprime Helo Byd!

Edição : Eu esqueci que adicionar UDLRcaracteres interrompe o programa Fission, então eu mudei as cordas para evitar isso.

4 idiomas, 75 bytes

#"Hej Verden!"o|
print ([]and(0and"Hola món!"or"Helo Byd!")or"Hai dunia!")

Python -Hai dunia!

Perl -Helo Byd!

Ruby -Hola món!

Palheiro -Hej Verden!

7 idiomas, 221 bytes

<?php echo'مرحبا بالعالم!';die?>h+#;"!dlereW ollaH"ck,@;
;echo Kaixo Mundua!;                        <@,k+4f"ሰላም ልዑል!"

Բարեւ աշխարհ!
@,k+4f"Përshendetje Botë!";XXXX;"Hello Wêreld!"

Como este programa contém alguns caracteres desagradáveis, aqui está um xxd:

00000000: 3c3f 7068 7020 6563 686f 27d9 85d8 b1d8  <?php echo'.....
00000010: add8 a8d8 a720 d8a8 d8a7 d984 d8b9 d8a7  ..... ..........
00000020: d984 d985 2127 3b64 6965 3f3e 682b 233b  ....!';die?>h+#;
00000030: 2221 646c 6572 6557 206f 6c6c 6148 2263  "!dlereW ollaH"c
00000040: 6b2c 403b 0a0c 3b65 6368 6f20 4b61 6978  k,@;..;echo Kaix
00000050: 6f20 4d75 6e64 7561 213b 2020 2020 2020  o Mundua !;
00000060: 2020 2020 2020 2020 2020 2020 2020 2020
00000070: 2020 3c40 2c6b 2b34 6622 e188 b0e1 888b    <@,k+4f"......
00000080: e188 9d20 e188 8de1 8b91 e188 8d21 220a  ... .........!".
00000090: 0ad4 b2d5 a1d6 80d5 a5d6 8220 d5a1 d5b7  ........... ....
000000a0: d5ad d5a1 d680 d5b0 210a 402c 6b2b 3466  ........!.@,k+4f
000000b0: 2250 c3ab 7273 6865 6e64 6574 6a65 2042  "P..rshendetje B
000000c0: 6f74 c3ab 2122 3b58 5858 583b 2248 656c  ot..!";XXXX;"Hel
000000d0: 6c6f 2057 c3aa 7265 6c64 2122 0a         lo W..reld!".

• Impressões Unefunge-98 Përshendetje Botë!- Experimente online!
• Impressões Befunge-98 Hallo Wereld!- Experimente online!
• Impressões Trefunge-98 ሰላም ልዑል!- Experimente online!
• Realmente imprime Hello Wêreld!- Experimente online!
• Impressões Bash Kaixo Mundua!- Experimente online!
• Impressões PHP مرحبا بالعالم!- Experimente online!
• Impressões de retina Բարեւ աշխարհ!- Experimente online!

5 idiomas, 168 bytes

  //"!nedreV jeH",,,,,,,,,,,@R"Hello World!"*#x
///"!mliaam ereT">:?v; x"!dyB oleH"           %x
//               ^ o<                         x
// >`Sawubona Mhlaba!`;

Eu acho que as linguagens bidimensionais são interessantes.

> <> impressões Tere maailm!
Befunge-98 impressões de Hej Verden!
cera de abelha impressões de Sawubona Mhlaba!
cardeais impressões de Helo Byd!
fissãoHello World!

Experimente online! (Cardeal)

2 idiomas, 16 caracteres, 24 bytes

Bem, pelo menos é mais curto que as duas cordas.

L"שלום עולם"33ç«

05AB1E -שלום עולם!

Ajuda, WarDoq! -Hello World!

_{Ajuda, WarDoq! pode adicionar dois números e testar primos, por isso é considerada uma linguagem de programação válida para este meta post .}

3 idiomas, 67 62 bytes

Para se qualificar para essa recompensa (100 rep).

x:Helo Byd!
O
y:"Hai dunia!"
u?`h;`4$'5^5D+Asi:^:E+IvIvAB*vhm,

Adicionar ++: Experimente online!

Foo: Experimente online!

Somme: Experimente online!

Explicação

Adicionar ++

Adicionar ++ vê:

x:Helo Byd!
O

" xString de saída "

y:"Hai dunia!"

"Defina y para uma sequência diferente"

u?`h;`4$'5^5D+Asi:^:E+IvIvAB*vhm,

"idk algo estranho, eu vou errar"

Foo

Foo vê:

x:Helo Byd!
O
y:"Hai dunia!"

"Oo, citações, eu produzo essas."

u?`h;`4$'5^5D+Asi:^:E+IvIvAB*vhm,

"Uh ... algo sobre um modo? Idk, eu vou errar."

Somme

Somme vê, bem, isso:

8s+vi:4+vhIvE-Asi:^:E+IvIvAB*vhm,

Cada coluna é convertida em pontos de código e, em seguida, 32 são subtraídos deles, e cada um é obtido no módulo 95. Isso corresponde a esses caracteres, que exibem "Hei Verden!"

4 idiomas, 138 bytes

''' '/*' '''
print(["Bonjour monde!","Hei maailma!","Hallo Wereld!"][((int(not 0)is 1)+2*int(1/2==0))-1])
''' '*/print("Hallo Welt!")' '''

Experimente online!

Py1, Py2, Py3, Proton; graças ao Sr. Xcoder; traduzido da resposta de Zacharý

4 idiomas, 115 bytes

print ((("b" + "0" == 0)and eval('"Hallo Wereld!"'))or(0 and"Hello World!"or(1/2and"Hei Verden!"or"Hej Verden!")));

Perl 5 dá Hallo Wereld!- TIO

Ruby dá Hello World!- TIO

Python 2 dá Hej Verden!- TIO

Python 3 dá Hei Verden!- TIO

Quatro idiomas, uns impressionantes 650 bytes

//iiciccepepceaiiiaiaiaicccsascciijceeeeeejccijjccjceaajaajcccjeeejaajaaijcccej
//[
/*
GOTO end
*/
//pis
//p
//p
//\u000Apublic class Main{public static void main(String[]a){System.out.print("Salut Lume!");}}
/*
lblend
print Hola Mundo!
//s
*/
//]
//s
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++++++++++++++++++++++++++++++++++++++.--------.++++++++++++++.-------------------------------------------------------------------------------.+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.++.-.----------.+++++++++++.------------------------------------------------------------------------------.

Java dá "Salut Lume!" Tente!

SILOS dá "Hola Mundo" Experimente!

Brainfuck dá "Ciao mondo!" Tente!

(O código alphuck é modificado na página Esolangs em Alphuck )

Alphuck dá "Olá Mundo!" Tente!

A linha que começa com \ u000A é o código Java. O código da linha um é o código Alphuck, que ignorará o restante do código (desde que "p" e "s" estejam equilibrados. A linha relevante para SIL / SILOS é "print Hola Mundo" e o código brainfuck está no final e ignorará o restante do código.

5 idiomas, 213 bytes

Decidi tentar escrever uma pequena resposta.

#include<stdio.h>
#define hint(x)int main(){auto i=.5;puts(i?"Hallo Welt!":"Hei maailma!");}
#define R "Pozdrav svijete!";
#if 0
hint=print
goto=len
s="Tere maailm!"
goto("endif")
s="Hallo Wereld!";
#endif
hint(s)

Línguas:

C:                                       Hei maailma!      (Finnish)
C++:                                     Hallo Welt!       (German)
Python 3:                                Hallo Wereld!     (Dutch)
Operation Flashpoint scripting language: Tere maailm!      (Estonian)
Fission:                                 Pozdrav svijete!  (Croatian)

C e C ++ vêem o código como:

#include<stdio.h>
#define hint(x)int main(){auto i=.5;puts(i?"Hallo Welt!":"Hei maailma!");}
#define R "Pozdrav svijete!"; // Unused macro
hint(s)

auto i=.5;é (com efeito) igual a int i=0;C, mas igual a double i=0.5;C ++.

Experimente online! (como C)

Experimente online! (como C ++)

O Python 3 vê o código como:

hint=print
goto=len
s="Tere maailm!"
goto("endif")         # Calculate string length and discard the result.
s="Hallo Wereld!"
hint(s)

Experimente online!

A linguagem de script OFP vê:

; (A semicolon at the beginning of a line comments the line in a script.)

; Four labels with strange names.
#include<stdio.h>
#define hint(x)int main(){auto i=.5;puts(i?"Hallo Welt!":"Hei maailma!");}
#define R "Pozdrav svijete!";
#if 0

; Assign a null value to "hint", no practical effect. Same for "goto".
hint=print
goto=len

; Assign the string to variable "s".
; I would like to have used the Czech phrase for OFP (because it's a Czech game),
; but it didn't recognize the 'ě' and printed a '?' instead.
s="Tere maailm!"

; Jump to label "endif".
goto("endif")

; This reassignment of "s" gets skipped.
s="Hallo Wereld!";

; Declare a label called "endif".
#endif

; Print the string "s".
hint(s)

A fissão vê:

R "Pozdrav svijete!";

Experimente online!

3 idiomas, 184 181 bytes

Funciona apenas uma vez - você precisa limpar a lista para executá-la novamente.

when gf clicked
add<[]=[]>to[c v
if<(join(item(1 v)of[c v])[d])=[1d
say[Helo Byd!
else
repeat(300000
add[]to[c v
end
if<(length of[c v])>[250000
say[Hello world!
else
say[Hai dunia!

Raspadinha 1.4: Helo Byd!

Scratch 2.0: Hello world!

Scratch 3.0 beta no momento desta resposta: Hai dunia!

Explicação

No Scratch 1.4, adicionar um booleano a uma lista adiciona 1or 0, mas no 2.0 e acima adiciona trueor false, mas ao verificar se o item é igual a 1<[] = []>, ele retornará true se o item for 1ou true, adicionamos outra letra a ela e verificamos isso.

No Scratch 3.0, as listas têm um tamanho máximo de 200.000 itens; portanto, apenas adicionamos vários itens e veremos se a lista é longa.

3 idiomas, 61 bytes

;“,ḷṅḳȦ»Ḋḷ“
x:Hai dunia!
O
y:"Helo Byd!"
;”

Adicionar saídas ++Hai dunia!

Saídas de geléiaHello World!

Saídas FooHelo Byd!

Só porque defini a recompensa não significa que não posso participar: D (ab) usa o brilhante truque de configuração de string que Conor encontrou para adicionar ++

Como funciona

Adicionar ++

;“,ḷṅḳȦ»Ḋḷ“     ; A comment. This does nothing
x:Hai dunia!    ; Set the x accumulator to the string "Hai dunia!"
O               ; Output x
y:"Helo Byd!"   ; Set the y accumulator to the string "Helo Byd!"
;”              ; Another comment

Geléia

Os comentários no Jelly podem ser formados com a sintaxe ḷ“comment”, que é como os códigos Add ++ e Foo são ignorados. O código que é realmente executado pelo Jelly é

;“,ḷṅḳȦ»Ḋ - Main link. Arguments: None
 “,ḷṅḳȦ»  - Yield the string "Hello World!"
;         - Append 0, yielding "0Hello World!"
        Ḋ - Remove the first character, yielding "Hello World!"

Foo

Foo ignora todos os caracteres aqui, exceto o "Helo Byd!"que, como está entre aspas, é emitido.