Tarea

Cree un programa o una función que sea válida en múltiples lenguajes de programación, y cuando se compila / interpreta como un lenguaje diferente genera "¡Hola, mundo!" en un lenguaje natural diferente

Por ejemplo, una solución válida podría generar Hello World!(inglés) cuando se compila y ejecuta como C, Hallo Welt!(alemán) cuando se compila y ejecuta como C ++ y 你好世界！(chino) cuando se ejecuta como Python.

Reglas

Para evitar la ambigüedad sobre la validez de una respuesta, a continuación hay una lista de versiones permitidas de la frase en varios idiomas. La lista consta de la frase en los idiomas para los cuales Google Translate tiene una traducción verificada por la comunidad de la frase (a partir de este escrito). *

La precisión de estas traducciones es discutible, pero son lo que usará este desafío. Las cadenas impresas deben seguir exactamente el formato a continuación (con la excepción de los espacios en blanco iniciales o finales).

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!

Así que hay 74 idiomas que se pueden usar.

Criterio ganador

La solución que puede generar la frase en la mayor cantidad de idiomas gana. En caso de empate, gana la solución más corta (en bytes).

_{* Las traducciones para malgache y maltés se marcaron como verificadas por la comunidad, pero eran claramente incorrectas (una era simplemente "¡Hola mundo!" Y la otra "¡Hola dinja!", Pero "¡Hola!" Solo se traduce como "¡Bongu!"). Estos fueron excluidos. También algunos idiomas (árabe, hebreo, pashto, persa y yiddish) se leen de derecha a izquierda en Google Translate, pero cuando se copian aquí, se leen de izquierda a derecha. Espero que esté bien.}

23 Befunges, 713 bytes

El único idioma que realmente conozco es Befunge, por lo que, en lugar de varios idiomas, acabo de implementar múltiples implementaciones de Befunge. Creo que esto todavía es válido según las reglas PPCG, que consideran el lenguaje que se definirá por su implementación .

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!!!!!!!!!!!!!!!!!

Lo frustrante de Befunge es que, aunque existe una implementación de referencia de código abierto y el lenguaje en sí es muy simple, no hay un solo intérprete de terceros (que yo sepa) que coincida exactamente con el comportamiento de referencia. Cada implementación falla de una manera diferente.

En el lado positivo, esto nos da la oportunidad de desarrollar una sola pieza de código que producirá un resultado diferente en casi todos los intérpretes. Y eso es lo que estoy intentando en el programa anterior.

Si alguien está interesado en verificar los resultados, he intentado agrupar las diversas implementaciones en categorías en función de lo fácil que es ponerlas en funcionamiento (por ejemplo, algunas personas pueden no ser capaces de ejecutar los archivos binarios de Windows o no estar dispuestos a hacerlo). construir desde la fuente, pero todos deberían poder probar los intérpretes en línea).

Intérpretes en línea

No requiere instalación. Por lo general, solo es cuestión de pegar el código y hacer clic en uno o dos botones. Pero tenga en cuenta que algunos de estos son bastante lentos, por lo que puede necesitar algo de tiempo para finalizar la ejecución.

Haga clic en el Clear...botón y pegue el código en el campo de entrada. Mueva el Editinterruptor para activar el intérprete y luego haga clic en el Runbotón para comenzar a ejecutar.
Tenga en cuenta que este sitio probablemente no funcionará en otros navegadores que no sean Chrome.

Pegue el código en el campo de entrada, asegurándose de sobrescribir el código existente. Luego haga clic en el Runbotón para ejecutar.

Pegue el código en el campo de entrada de Playfield y luego haga clic en el Runbotón para comenzar a ejecutar.

Pegue el código en el campo de entrada debajo del Showbotón, asegurándose de sobrescribir el @que ya está allí. Haga clic en el Showbotón para importar el código, luego haga clic en el Runbotón para comenzar a ejecutar.

Primero cierre el cuadro de diálogo Ayuda , luego haga clic en el botón Abrir / Importar barra de herramientas (segundo desde la izquierda), pegue el código y haga clic OK. Para ejecutar, haga clic en el botón Modo de ejecución (cuarto desde la izquierda) y luego en Iniciar (quinto desde la izquierda).

También tenga en cuenta que algunos de los intérpretes basados ​​en consola están realmente disponibles en TIO, por lo que si bien no son técnicamente intérpretes en línea, pueden probarse en línea. Para aquellos que son compatibles (actualmente BEF, FBBI, MTFI y PyFunge), ¡he incluido un Try It Online! enlace al lado de su entrada.

IDEs de Java

Deberá tener instalado el tiempo de ejecución de Java para estos, pero en teoría deberían funcionar en cualquier plataforma. Sin embargo, solo se probó en Windows.

Inicialmente, este era un applet en línea que desafortunadamente ya no está disponible, pero aún puede descargar el jar y ejecutarlo localmente como una aplicación de escritorio. Deberá pegar el código en la ventana del Editor de programas , luego hacer clic en el Convertbotón, seguido del Runbotón.

Para pegar el código, haga clic derecho en la esquina superior izquierda de la ventana del editor ( debe ser la esquina superior izquierda) y seleccione el elemento de menú Pegar . Luego, active la casilla de verificación Velocidad máxima (de lo contrario, tomará una eternidad) y haga clic en el Run!botón para comenzar a ejecutar.

Presione Ctrl+ A, Ctrl+ Vpara pegar el código en la ventana del editor, asegurándose de sobrescribir la fuente predeterminada. Luego haga clic en el Startbotón para comenzar a ejecutar.

IDEs de Windows

Normalmente necesitará Windows para estos, aunque en algunos casos puede haber binarios disponibles para otros sistemas operativos. Sin embargo, no puedo prometer que el código funcionará en otras plataformas.

No puede pegar el código en el editor, por lo que primero deberá guardarlo en el disco en alguna parte. Luego, desde el IDE, use el menú Archivo> Abrir para cargar el código del disco y seleccione el menú Simulación> Ejecutar / Pausa para ejecutarlo.

Presione Ctrl+ Vpara pegar el código y luego haga clic en el botón de la barra de herramientas de depuración (el engranaje azul) para comenzar a ejecutar. Una vez que aparezca el panel Depurador , querrá establecer la Velocidad al máximo (el botón a la derecha del control deslizante); de lo contrario, tomará una eternidad terminar.

Presione Ctrl+ Vpara pegar el código y luego presione F5para ejecutarlo.

No puede pegar el código en el editor, por lo que primero deberá guardarlo en el disco en alguna parte. Luego, desde el IDE, presione Ctrl+ Opara abrir el explorador de archivos y cargue el código del disco, y presione F5para ejecutarlo.

Aplicaciones de consola de Windows

Nuevamente, estos normalmente requieren Windows, aunque otras plataformas pueden estar disponibles, pero no se garantiza que funcionen.

En todos los casos, el código deberá guardarse en un archivo en el disco y el nombre del archivo pasará al intérprete como un parámetro de línea de comando ( source.bf en las líneas de comando de ejemplo que figuran a continuación). También tenga en cuenta que algunos de estos son técnicamente intérpretes Befunge-98, y deben ejecutarse con una opción particular de línea de comandos para forzar un modo de compatibilidad Befunge-93. Si no haces eso, no obtendrás los resultados correctos.

Línea de comando: bef93w32 -q source.bf

Línea de comando: ccbi --befunge93 source.bf

Línea de comando: mtfi -3 source.bf(¡ Pruébelo en línea! )

Aplicaciones de consola Python y PHP

Estos requieren el lenguaje de scripting apropiado instalado, ya sea Python o PHP.

Línea de comando: befungee.py source.bf

Línea de comando: pyfunge -v 93 source.bf(¡ Pruébelo en línea! )

Línea de comando: php bephunge.phps source.bf

Aplicaciones de consola solo de origen

Deberán construirse desde la fuente, y eso suele ser más fácil con un entorno similar a * nix. En Windows uso el Subsistema de Windows para Linux .

Línea de comando: bef -q source.bf(¡ Pruébelo en línea! )

Línea de comando: cfunge -s 93 source.bf

Línea de comando: fbbi -93 source.bf(¡ Pruébelo en línea! )

Línea de comando: fungi source.bf

Línea de comando: rcfunge -93 source.bf

Cómo funciona

El desafío con esto fue encontrar la menor cantidad de pruebas que proporcionaran la mayor diferenciación entre los intérpretes. Al final se redujo a cuatro secuencias de prueba principales:

1. El primero es una lectura de memoria fuera de límites del desplazamiento -1,1. En teoría, esto siempre debería devolver 32 (espacio ASCII), pero en realidad hubo 10 variaciones en la práctica. Esta prueba se complica por el hecho de que dos de los intérpretes fallan en una lectura fuera de límites, por lo que se requirieron un par de pruebas de casos especiales (redondeo de división y puente de espacio) para obligar a esos dos a volver a los límites.

2. La segunda secuencia es una prueba de la funcionalidad de Befunge-98, específicamente las instrucciones ;y '. Casi todos los intérpretes son Befunge-93, o se ejecutan en modo de compatibilidad Befunge-93, por lo que deberían ignorar esas instrucciones. En la práctica, hubo 6 formas diferentes de interpretar esta secuencia.

3. La tercera prueba verifica el rango de celdas de memoria. En el intérprete de referencia, las celdas de memoria están firmadas de 8 bits, pero otras implementaciones varían en el rango de 8 bits a sin límite, algunas con signo y otras sin signo. Sin embargo, para los propósitos de esta prueba, solo tuvimos que distinguir entre 5 de esas variantes.

4. La cuarta y última secuencia es una combinación de pruebas de flujo negativo y división negativa. Hay varias formas en que los intérpretes se equivocan, y hay al menos 3 formas diferentes en que se implementan las instrucciones de división y módulo, pero solo hay 3 combinaciones que nos interesan aquí.

Cada una de estas secuencias devolvió un solo número, y esos cuatro números se combinaron (a través de algunas tablas básicas de aritmética y traducción) para producir un valor final en el rango de 0 a 22. Ese valor podría usarse como un índice para buscar el mensaje real para 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!?%?"

Pruébalo en línea!

(use "cambiar idiomas" para cambiar el idioma)

• Python 3 = Halo Dunia! (Indonesio)

• Python 2 = Hej Verden! (Danés)

• Python 1 = Hai dunia! (Malayo)

• C (gcc) = ¡Hola Byd! (Galés)

• C ++ (gcc) = Halo Dunya! (Sundanés)

• Objetivo C (clang) = ¡Hola Welt! (Alemán)

• Brainfuck = Hola Mundo! (Inglés, obviamente)

• Befunge-93 = Salut Lume! (Rumano)

• Ruby = Moien Welt! (Luxemburgués)

• Bash = Salom Dunyo! (Uzbeko)

• Befunge-98 (PyFunge) = Kaixo Mundua! (Vasco)

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

• Cardenal = ¡Hola, Wereld! (Holandés)

• Alphuck = Ciao mondo! (Italiano)

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

• Fisión = Pozdrav svijete! (Croata)

¡Cualquier consejo de golf es bienvenido (especialmente en Brainfuck)!

¡Gracias a @JonathanFrech por -1 byte! Además, ¡gracias a @ovs por -40 bytes!

¿Cómo (ideas generales, en realidad olvidé detalles)?

Los idiomas se pueden poner en cuatro grupos:

• Macro: C, C ++, Objetivo C
• Comentario: Python3, Python2, Python1, Ruby, Bash
• Dimensional: Befunge-93, Befunge-98, Unefunge-98, Cardenal,> <>, Fisión
• Vulgar: Brainfuck, Alphuck

Los lenguajes macro se ven #como el inicio de una directiva de preprocesador. Estos se utilizan por tres razones: para albergar código para otros grupos, para distinguir entre lenguajes Macro y para definir realmente una macro. Los tres se usan //como comentario, por lo que luego almacenamos el código para los otros grupos. Además, la barra diagonal inversa continúa el comentario en estos idiomas.

Los idiomas de comentario se ven #como el comienzo de un comentario. La peculiaridad aquí son las comillas triples, que distinguen a las pitones de Ruby de Bash. Y para distinguir Python 1 de 2 de 3, utilizamos una característica distintiva en los tres, junto con una serie de resultados. Oh sí, también hay eso __END__. Esto se utiliza para finalizar el código para algunos (no recuerdo exactamente cuáles) de los idiomas de comentario.

Los lenguajes dimensionales se distinguen de una manera que es difícil de explicar. Uno tiene que conocer los detalles de cada idioma para descubrirlo. Por ejemplo, #es solo un salto en los fungeoides, mientras que hace varias cosas diferentes en los otros idiomas. El código está esparcido por todas partes para estos idiomas.

Y finalmente, llegamos a las lenguas vulgares. Estos dos ignoran todo lo que no está en su conjunto de caracteres válidos. Se debe jugar un acto de equilibrio con estos idiomas y los demás, ya que el código ya contiene caracteres en los 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+++[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.
   	  	   
	
     		  	 	
	
     		 		  
	
     		 				
	
     	     
	
     	    	 
	
     				  	
	
     		  	  
	
     	    	
	
  

Pruébalo en línea!

1. Kaixo Mundua! en Befunge-93
2. Hej Verden! en fisión
3. Tere maailm! en Unefunge-98
4. Hei maailma!! en Befunge-98
5. Hai dunia! en> <>
6. Hola món! en Ruby
7. Hola Mundo! en GolfScript
8. Hallo Welt! en bash
9. Ndewo Ụwa! en ksh
10. Ciao mondo! en el tablero
11. Moien Welt! en zsh
12. Hei Verden! en ceniza
13. Olá Mundo! en cardenal
14. Hello World!en brainfuck, cortesía de primo .
15. Helo Byd! en espacio en blanco

Explicación

La línea 1 distingue entre cinco esolangs 2D:

1. ><>se lee #como un espejo, se envuelve a la izquierda, imprime "Hai dunia!"y se bloquea ( @). Todos los Funges lo leen como un trampolín y van a la derecha.
2. Befunge-93 ignora ;, imprime Kaixo Mundua!y sale ( @).
3. Los '98 Funges saltan del primero ;al segundo, luego del tercero ;al cuarto. wes un NOP para Befunge-98, impresión Hei maailma!.
4. Pero wrefleja el puntero de instrucciones en Unefunge-98, la impresión Tere maailm!.
5. La fisión no comienza en la esquina superior izquierda en absoluto. R"Hej Verden!";es ejecutado. (Otro puntero de instrucción comienza desde Dadentro __END__, pero no hace nada y luego muere hacia ;adentro true;)

Ruby ve `true #{puts'Hola món!'}`, entonces __END__.

GolfScript ve `, luego true(NOP), luego un comentario; entonces __END__(NOP); entonces "Hola Mundo!" puts(esto se ejecuta); luego case(NOP), luego `(se bloquea en la pila vacía).

Los shells ven un comentario, luego una invocación a true(NOP), luego invocaciones a comandos desconocidos __END__y "Hola Mundo!"(que error a STDERR pero la ejecución continúa), luego la casedeclaración que distingue según la primera letra del nombre del proceso actual.

Cardinal es otro esolang 2D que comienza en el %, enviando 4 IP hacia arriba, abajo, izquierda y derecha. Todos son asesinados por los xcomandos circundantes , pero uno imprime "Olá Mundo!"antes de morir.

El código de brainfuck es primo, con el prefijo ++para contrarrestar los guiones ps -p$$ -oargs=.

El espacio en blanco en mi código se ejecuta como el programa de espacios en blanco

 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!

EDITAR : Olvidé que agregar UDLRcaracteres interrumpe el programa Fission, por lo que he cambiado las cadenas para evitarlos.

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!

rubí -Hola món!

Pajar -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 contiene algunos caracteres desagradables, aquí hay un 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!".

• Impresiones Unefunge-98 Përshendetje Botë!- ¡ Pruébelo en línea!
• Impresiones Befunge-98 Hallo Wereld!- ¡ Pruébelo en línea!
• Impresiones Trefunge-98 ሰላም ልዑል!- ¡ Pruébelo en línea!
• Realmente imprime Hello Wêreld!- ¡ Pruébelo en línea!
• Impresiones Bash Kaixo Mundua!- ¡ Pruébelo en línea!
• Impresiones PHP مرحبا بالعالم!: ¡ Pruébelo en línea!
• Impresiones de retina Բարեւ աշխարհ!: ¡ pruébelo en línea!

5 idiomas, 168 bytes

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

Creo que los lenguajes bidimensionales son interesantes.

> <> impresiones Impresiones Tere maailm!
Befunge-98 Impresiones de Hej Verden!
cera de abejas Impresiones Sawubona Mhlaba!
cardinales Impresiones de Helo Byd!
fisiónHello World!

Pruébalo en línea! (Cardenal)

2 idiomas, 16 caracteres, 24 bytes

Bueno, al menos eso es más corto que ambas cuerdas.

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

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

Ayuda, WarDoq! -Hello World!

_{Ayuda, WarDoq! puede agregar dos números y probar primos, por lo que se considera un lenguaje de programación válido según esta meta publicación .}

3 idiomas, 67 62 bytes

Para calificar para esta recompensa (100 repeticiones).

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

Añadir ++: ¡ Pruébelo en línea!

Foo: ¡ Pruébalo en línea!

Somme: ¡ Pruébalo en línea!

Explicación

Añadir ++

Agregar ++ ve:

x:Helo Byd!
O

" xCadena de salida "

y:"Hai dunia!"

"Establezca y en una cadena diferente"

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

"Idk algo raro, voy a error"

Foo

Foo ve:

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

"Oo, citas, las sacaré".

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

"Uh ... ¿algo sobre un modo? Idk, me equivocaré".

Somme

Somme ve, bueno, esto:

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

Cada columna se convierte en puntos de código, luego se resta 32 de ellos, luego se toma cada módulo 95. Esto corresponde a estos caracteres, que imprimen, "¡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!")' '''

Pruébalo en línea!

Py1, Py2, Py3, Protón; gracias al señor Xcoder; traducido de la respuesta 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 da Hallo Wereld!- TIO

Ruby da Hello World!- TIO

Python 2 da Hej Verden!- TIO

Python 3 da Hei Verden!- TIO

Cuatro idiomas, la friolera de 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 da "Salut Lume!" ¡Intentalo!

SILOS da "Hola Mundo" ¡ Pruébalo!

Brainfuck da "Ciao mondo!" ¡Intentalo!

(El código alphuck se modifica desde la página de Esolangs en Alphuck )

Alphuck da "¡Hola mundo!" ¡Intentalo!

La línea que comienza \ u000A es el código Java. El código en la línea uno es el código Alphuck, que ignorará el resto del código (siempre que "p" y "s" estén equilibradas. La línea relevante para SIL / SILOS es "imprimir Hola Mundo", y el código brainfuck está al final e ignorará el resto del código.

5 idiomas, 213 bytes

Decidí intentar escribir una pequeña respuesta yo mismo.

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

Idiomas:

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 y C ++ ven el 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;es (en efecto) igual a int i=0;en C, pero igual a double i=0.5;en C ++.

Pruébalo en línea! (como C)

Pruébalo en línea! (como C ++)

Python 3 ve el código como:

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

Pruébalo en línea!

El lenguaje de script OFP ve:

; (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)

La fisión ve:

R "Pozdrav svijete!";

Pruébalo en línea!

3 idiomas, 184 181 bytes

Solo funciona una vez: debe borrar la lista para volver a ejecutarla.

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!

Scratch 1.4: Helo Byd!

Scratch 2.0: Hello world!

Scratch 3.0 beta al momento de esta respuesta: Hai dunia!

Explicación

En Scratch 1.4, agregar un booleano a una lista agrega 1o 0, pero en 2.0 y más, agrega trueo false, pero al verificar si el elemento es igual a 1<[] = []>, devolverá verdadero si el elemento es 1o true, así que le agregamos otra carta y lo verificamos.

En Scratch 3.0, las listas tienen un tamaño máximo de 200,000 elementos, por lo que solo agregamos un montón de elementos y vemos si la lista es tan larga.

3 idiomas, 61 bytes

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

Agregar salidas ++Hai dunia!

Salidas de gelatinaHello World!

Salidas FooHelo Byd!

El hecho de que establezca la recompensa no significa que no pueda participar: D (ab) usa el truco de configuración de cadena brillante que Conor encontró para Add ++

Cómo funciona

Añadir ++

;“,ḷṅḳȦ»Ḋḷ“     ; 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

Jalea

Los comentarios en Jelly se pueden formar con la sintaxis ḷ“comment”, que es cómo se ignoran los códigos Add ++ y Foo. El código que realmente ejecuta Jelly es

;“,ḷṅḳȦ»Ḋ - 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 los caracteres aquí aparte de "Helo Byd!", que, como está entre comillas, se genera.