Tâche

Créez un programme ou une fonction qui est valide dans plusieurs langages de programmation et qui, une fois compilé / interprété en tant que langage différent, génère "Hello, World!" dans un langage naturel différent.

Par exemple, une solution valide peut générer Hello World!(anglais) lorsqu’elle est compilée et s’exécuter en tant que C Hallo Welt!(allemand) lorsqu’elle est compilée et s’exécuter en tant que C ++ et 你好世界！(chinois) lorsqu’elle est exécutée en tant que Python.

Règles

Pour éviter toute ambiguïté sur la validité d'une réponse, vous trouverez ci-dessous une liste des versions autorisées de la phrase dans plusieurs langues. La liste est composée de la phrase dans les langues pour lesquelles Google Translate a une traduction de la phrase vérifiée par la communauté (à ce jour). *

La précision de ces traductions est discutable, mais c’est ce que ce défi utilisera. Les chaînes imprimées doivent suivre exactement le format ci-dessous (à l'exception des espaces de début et de fin).

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!

Donc, il y a 74 langues qui peuvent être utilisées.

Critère gagnant

La solution permettant d’exprimer la phrase dans le plus grand nombre de langues est retenue. En cas d'égalité, la solution la plus courte (en octets) l'emporte.

_{* Les traductions pour le malgache et le maltais étaient marquées comme vérifiées par la communauté, mais étaient clairement incorrectes (l'une était simplement "Hello World!" Et l'autre "Hello dinja!", Mais "Hello!" Se traduit uniquement par "Bongu!"). Ceux-ci ont été exclus. De plus, certaines langues (arabe, hébreu, pachtou, persan et yiddish) se lisent de droite à gauche dans Google Translate, mais lorsqu'elles sont copiées ici, elles se lisent de gauche à droite. J'espère que ça va.}

23 fusions, 713 octets

Le seul langage que je connaisse vraiment est Befunge, alors au lieu de plusieurs, je viens d’utiliser plusieurs implémentations de Befunge. Je crois que cela est toujours valable en vertu des règles du PPCG, qui considèrent le langage comme étant défini par sa mise en œuvre .

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

Ce qui est frustrant à propos de Befunge, c’est que, même s’il existe une implémentation de référence open source et que le langage lui-même est extrêmement simple, il n’existe pas un seul interpréteur tiers (à ma connaissance) correspondant au comportement de référence. Chaque implémentation échoue de manière différente.

Sur le plan positif, cela nous donne l’opportunité de développer un code unique qui produira un résultat différent dans presque chaque interprète. Et c'est ce que je tente dans le programme ci-dessus.

Si quelqu'un souhaite vérifier les résultats, j'ai essayé de regrouper les différentes implémentations en catégories, en fonction de leur facilité de mise en œuvre (par exemple, certaines personnes peuvent ne pas être en mesure d'exécuter des fichiers binaires Windows ou peuvent ne pas être disposées à le faire. construire à partir des sources, mais tout le monde devrait pouvoir tester les interprètes en ligne).

Interprètes en ligne

Aucune installation requise. Il suffit généralement de coller le code et de cliquer sur un bouton ou deux. Mais notez que certaines d’entre elles sont assez lentes et peuvent donc nécessiter un peu de temps pour terminer l’exécution.

Cliquez sur le Clear...bouton et collez le code dans le champ de saisie. Basculez le Editcommutateur pour activer l'interprète, puis cliquez sur le Runbouton pour lancer l'exécution.
Notez que ce site ne fonctionnera probablement pas dans un navigateur autre que Chrome.

Collez le code dans le champ de saisie en veillant à écraser le code existant. Puis cliquez sur le Runbouton pour exécuter.

Collez le code dans le champ de saisie Playfield , puis cliquez sur le Runbouton pour lancer l’exécution.

Collez le code dans le champ de saisie situé sous le Showbouton, en veillant à remplacer le texte existant @. Cliquez sur le Showbouton pour importer le code, puis sur Runpour lancer l'exécution.

Fermez d'abord la boîte de dialogue Aide , puis cliquez sur le bouton Ouvrir / Importer de la barre d'outils (deuxième en partant de la gauche), collez le code et cliquez sur OK. Pour l'exécuter, cliquez sur le bouton Mode d' exécution (quatrième à gauche), puis sur Démarrer (cinquième à gauche).

Notez également que quelques-uns des interprètes basés sur la console sont actuellement disponibles sur TIO. Par conséquent, bien qu'ils ne soient pas techniquement des interprètes en ligne, ils peuvent être testés en ligne. Pour ceux qui sont pris en charge (actuellement BEF, FBBI, MTFI et PyFunge), j'ai inclus un essai en ligne! lien à côté de leur entrée.

IDEs Java

Le programme d’exécution Java doit être installé pour ces applications, mais elles devraient théoriquement fonctionner sur n’importe quelle plate-forme. Seulement testé sur Windows cependant.

Il s’agissait au départ d’un applet en ligne qui n’est malheureusement plus disponible, mais vous pouvez toujours télécharger le fichier jar et l’exécuter localement en tant qu’application de bureau. Vous devrez coller le code dans la fenêtre de l' éditeur de programme , puis cliquer sur le Convertbouton, puis sur le Runbouton.

Pour coller le code, cliquez avec le bouton droit de la souris dans le coin supérieur gauche de la fenêtre de l'éditeur (ce doit être tout en haut à gauche) et sélectionnez l' élément de menu Coller . Activez ensuite la case à cocher Pleine vitesse (sinon cela prendra une éternité), puis cliquez sur le Run!bouton pour commencer à exécuter.

Appuyez sur Ctrl+ A, Ctrl+ Vpour coller le code dans la fenêtre de l'éditeur, en veillant à remplacer la source par défaut. Puis cliquez sur le Startbouton pour commencer à exécuter.

IDE Windows

Vous aurez généralement besoin de Windows pour ces applications, bien que dans certains cas, des fichiers binaires puissent être disponibles pour d'autres systèmes d'exploitation. Je ne peux pas promettre que le code fonctionnera sur d'autres plateformes cependant.

Vous ne pouvez pas coller le code dans l'éditeur, vous devez donc d'abord l'enregistrer sur le disque quelque part. Ensuite, à partir de l'EDI, utilisez le menu Fichier> Ouvrir pour charger le code à partir du disque, puis sélectionnez le menu Simulation> Exécuter / Pause pour l'exécuter.

Appuyez sur Ctrl+ Vpour coller le code, puis cliquez sur le bouton de débogage de la barre d’outils (le rouage bleu) pour commencer l’exécution. Une fois que le panneau du débogueur apparaît, vous voudrez régler la vitesse au maximum - le bouton à droite du curseur - sinon, la fin prendra indéfiniment.

Appuyez sur Ctrl+ Vpour coller le code, puis appuyez sur F5pour l'exécuter.

Vous ne pouvez pas coller le code dans l'éditeur, vous devez donc d'abord l'enregistrer sur le disque quelque part. Ensuite, à partir de l'EDI, appuyez sur Ctrl+ Opour ouvrir le navigateur de fichiers, chargez le code à partir du disque et appuyez sur F5pour l'exécuter.

Applications de la console Windows

Là encore, ils nécessitent généralement Windows, bien que d’autres plates-formes puissent être disponibles, mais leur fonctionnement ne soit pas garanti.

Dans tous les cas, le code devra être enregistré dans un fichier sur le disque et le nom du fichier transmis à l'interpréteur en tant que paramètre de ligne de commande ( source.bf dans les exemples de lignes de commande donnés ci-dessous). Notez également que certains d'entre eux sont techniquement des interpréteurs Befunge-98 et doivent être exécutés avec une option de ligne de commande particulière pour forcer un mode de compatibilité Befunge-93. Si vous ne le faites pas, vous n'obtiendrez pas les bons résultats.

Ligne de commande: bef93w32 -q source.bf

Ligne de commande: ccbi --befunge93 source.bf

Ligne de commande: mtfi -3 source.bf( essayez-le en ligne! )

Applications console Python et PHP

Celles-ci nécessitent le langage de script approprié installé - Python ou PHP.

Ligne de commande: befungee.py source.bf

Ligne de commande: pyfunge -v 93 source.bf( essayez-le en ligne! )

Ligne de commande: php bephunge.phps source.bf

Applications de console source uniquement

Celles-ci devront être construites à partir des sources, ce qui est généralement plus facile avec un environnement de type * nix. Sous Windows, j'utilise le sous-système Windows pour Linux .

Ligne de commande: bef -q source.bf( essayez-le en ligne! )

Ligne de commande: cfunge -s 93 source.bf

Ligne de commande: fbbi -93 source.bf( essayez-le en ligne! )

Ligne de commande: fungi source.bf

Ligne de commande: rcfunge -93 source.bf

Comment ça fonctionne

Le défi à relever consistait à trouver le plus petit nombre de tests offrant la plus grande différenciation entre les interprètes. En fin de compte, il s’agissait de quatre séquences de tests principales:

1. Le premier est une mémoire hors limites lue à partir du décalage -1,1. En théorie, cela devrait toujours renvoyer 32 (espace ASCII), mais il y avait en fait 10 variations dans la pratique. Ce test est compliqué par le fait que deux des interprètes tombent en panne après une lecture en dehors des limites; deux ou trois tests dans des cas spéciaux (arrondi de division et séparation d'espace) ont donc été nécessaires pour les forcer à revenir dans les limites.

2. La deuxième séquence est un test de la fonctionnalité de Befunge-98, plus précisément des instructions ;et '. Presque tous les interprètes sont Befunge-93 ou sont exécutés en mode de compatibilité Befunge-93. Ils doivent donc ignorer ces instructions. En pratique, cette séquence a été interprétée de 6 manières différentes.

3. Le troisième test vérifie la plage de cellules mémoire. Dans l'interpréteur de référence, les cellules de mémoire sont signées sur 8 bits, mais les autres implémentations varient de 8 bits à sans limite, certaines signées et d'autres non signées. Cependant, pour les besoins de ce test, nous n'avons dû distinguer que 5 de ces variantes.

4. La quatrième et dernière séquence est une combinaison de tests de débordement et de division négative. Les interpréteurs se trompent de plusieurs manières, et il existe au moins trois manières différentes de mettre en œuvre les instructions de division et de modulo, mais nous ne tenons compte que de trois combinaisons.

Chacune de ces séquences a renvoyé un nombre unique, et ces quatre numéros ont été combinés (via des tables de calcul et de conversion de base) afin de produire une valeur finale comprise entre 0 et 22. Cette valeur pourrait ensuite être utilisée comme index pour rechercher le message réel. afficher.

16 langues, 1363 octets

 #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!?%?"

Essayez-le en ligne!

(utilisez "changer de langue" pour changer de langue)

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

• Python 2 = Hej Verden! (Danois)

• Python 1 = Hai Dunia! (Malais)

• C (gcc) = Helo Byd! (Gallois)

• C ++ (gcc) = Halo Dunya! (Sundanese)

• Objectif C (clang) = Hallo Welt! (Allemand)

• Brainfuck = Bonjour tout le monde! (Anglais, évidemment)

• Befunge-93 = Salut Lume! (Roumain)

• Ruby = Moien Welt! (Luxembourgeois)

• Bash = Salom Dunyo! (Ouzbek)

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

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

• Cardinal = Hallo Wereld! (Néerlandais)

• Alphuck = Ciao mondo! (Italien)

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

• Fission = Pozdrav svijete! (Croate)

Tous les conseils de golf sont les bienvenus (surtout sur le Brainfuck) !!

Merci à @JonathanFrech pour -1 octet! Merci également à @ovs pour -40 octets!

Comment (idées générales, j'ai en fait oublié des détails) ??

Les langues peuvent être classées en quatre groupes:

• Macro: C, C ++, Objective C
• Commentaire: Python3, Python2, Python1, Ruby, Bash
• Dimensions: Befunge-93, Befunge-98, Unefunge-98, Cardinal,> <>, Fission
• Vulgar: Brainfuck, Alphuck

Les langues Macro sont considérées #comme le début d'une directive de préprocesseur. Celles-ci sont utilisées pour trois raisons: héberger du code pour d'autres groupes, distinguer les langages de macro et définir une macro. Tous les trois sont utilisés //comme commentaires, nous enregistrons ensuite le code des autres groupes. En outre, la barre oblique inverse continue le commentaire dans ces langues.

Les langues de commentaires sont considérées #comme le début d'un commentaire. Le bizarre ici est les guillemets triples, qui distinguent les Pythons de Ruby de Bash. Et pour distinguer Python 1 de 2 de 3, nous utilisons une caractéristique distinctive dans les trois, avec un tableau de sorties. Oh oui, il y a aussi ça __END__. Ceci est utilisé pour terminer le code de certaines langues (je ne sais pas exactement lesquelles) des langues de commentaires.

Les langues dimensionnelles se distinguent de manière difficile à expliquer. Il faut connaître les spécificités de chaque langue pour le comprendre. Par exemple, #n’est qu’un saut dans les fongoïdes, alors qu’il fait différentes choses dans les autres langues. Le code est éparpillé partout pour ces langues.

Et finalement, nous arrivons aux langues vulgaires. Ces deux ignorent tout ce qui n'est pas dans leur ensemble de caractères valides. Un numéro d'équilibre doit être joué avec ces langues et les autres, car le code contient déjà des caractères dans les jeux de caractères.

15 langues, 532 octets

# ;"!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+++[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.
   	  	   
	
     		  	 	
	
     		 		  
	
     		 				
	
     	     
	
     	    	 
	
     				  	
	
     		  	  
	
     	    	
	
  

Essayez-le en ligne!

1. Kaixo Mundua! dans Befunge-93
2. Hej Verden! dans la fission
3. Tere maailm! dans Unfunge-98
4. Hei maailma!! dans Befunge-98
5. Hai dunia! dans> <>
6. Hola món! en rubis
7. Hola Mundo! dans GolfScript
8. Hallo Welt! en bash
9. Ndewo Ụwa! en ksh
10. Ciao mondo! en tiret
11. Moien Welt! en zsh
12. Hei Verden! en cendres
13. Olá Mundo! au cardinal
14. Hello World!dans le brainfuck, courtoisie de primo .
15. Helo Byd! dans les espaces blancs

Explication

La ligne 1 distingue cinq esolangs 2D:

1. ><>se lit #comme un miroir, tourne à gauche, imprime "Hai dunia!"et plante ( @). Tous les Funges le lisent comme un trampoline et vont à droite.
2. Befunge-93 ignore ;, imprime Kaixo Mundua!et quitte ( @).
3. Les '1998 Funges sautent du premier ;au second, puis du troisième ;au quatrième. west un NOP pour Befunge-98, impression Hei maailma!.
4. Mais wreflète le pointeur d'instruction dans Unefunge-98, l'impression Tere maailm!.
5. La fission ne commence pas du tout dans le coin supérieur gauche. R"Hej Verden!";est exécuté. (Un autre pointeur d’instruction commence à partir de l’ Dint __END__, mais il ne meurt pas, puis meurt à l’ ;int true;.)

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

GolfScript voit `, ensuite true(NOP), puis un commentaire; alors __END__(NOP); then "Hola Mundo!" puts(ceci est exécuté); puis case(NOP), puis `(se bloque sur une pile vide).

Les shells voient un commentaire, puis un appel à true(NOP), puis des invocations à des commandes inconnues __END__et "Hola Mundo!"(quelle erreur pour STDERR mais l'exécution continue), puis l' caseinstruction qui distingue en fonction de la première lettre du nom du processus en cours.

Cardinal est un autre esolang 2D qui commence à la %, en envoyant 4 adresses IP vers le haut, le bas, la gauche et la droite. Ils sont tous tués par les xcommandes environnantes , mais on imprime "Olá Mundo!"avant de mourir.

Le code brainfuck est celui de primo, préfixé par ++pour contrecarrer les tirets dans ps -p$$ -oargs=.

Les espaces dans mon code sont exécutés en tant que programme 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

qui imprime Helo Byd!

EDIT : J'ai oublié que l'ajout de UDLRcaractères interrompt le programme Fission, j'ai donc changé les chaînes pour les éviter.

4 langues, 75 octets

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

Haystack -Hej Verden!

7 langues, 221 octets

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

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

Puisque ce programme contient des caractères méchants, voici 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!".

• Unefunge-98 prints Përshendetje Botë!- Essayez-le en ligne!
• Befunge-98 prints Hallo Wereld!- Essayez-le en ligne!
• Trefunge-98 prints ሰላም ልዑል!- Essayez-le en ligne!
• Imprime réellement Hello Wêreld!- Essayez-le en ligne!
• Imprimés Bash Kaixo Mundua!- Essayez-le en ligne!
• Imprimés PHP مرحبا بالعالم!- Essayez-le en ligne!
• Retina prints Բարեւ աշխարհ!- Essayez-le en ligne!

5 langues, 168 octets

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

Je pense que les langues à deux dimensions sont intéressantes.

> <> impressions Tere maailm!
Befunge-98 impressions Hej Verden!
Cire d'abeille impressions Sawubona Mhlaba!
cardinales impressions Helo Byd!
FissionHello World!

Essayez-le en ligne! (Cardinal)

2 langues, 16 caractères, 24 octets

Eh bien, au moins, c'est plus court que les deux chaînes.

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

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

Aidez-moi, WarDoq! -Hello World!

_{Aidez-moi, WarDoq! peut ajouter deux nombres et tester les nombres premiers, il est donc considéré comme un langage de programmation valide par cette méta publication .}

3 langues, 67 à 62 octets

Pour être admissible à cette prime (100 rep).

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

Ajoutez ++: essayez-le en ligne!

Foo: Essayez-le en ligne!

Somme: Essayez-le en ligne!

Explication

Ajouter ++

Ajouter ++ voit:

x:Helo Byd!
O

" xChaîne de sortie "

y:"Hai dunia!"

"Réglez y sur une autre chaîne"

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

"idk quelque chose de bizarre, je vais erreur"

Foo

Foo voit:

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

"Oo, citations, je vais sortir ceux-là."

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

"Euh ... quelque chose à propos d'un mode? Idk, je vais me tromper."

Somme

Somme voit bien ceci:

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

Chaque colonne est convertie en points de code, puis on en soustrait 32, puis chacune est prise modulo 95. Cela correspond à ces caractères, qui affichent "Hei Verden!"

4 langues, 138 octets

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

Essayez-le en ligne!

Py1, Py2, Py3, Proton; merci à M. Xcoder; traduit de la réponse de Zacharý

4 langues, 115 octets

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

Perl 5 donne Hallo Wereld!- TIO

Ruby donne Hello World!- TIO

Python 2 donne Hej Verden!- TIO

Python 3 donne Hei Verden!- TIO

Quatre langues, 650 octets

//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 donne "Salut Lume!" Essayez le!

SILOS donne "Hola Mundo" Essayez-le!

Brainfuck donne "Ciao mondo!" Essayez le!

(Le code alphuck est modifié à partir de la page Esolangs sur Alphuck )

Alphuck donne "Bonjour le monde!" Essayez le!

La ligne commençant par \ u000A est le code Java. Le code de la première ligne est le code Alphuck, qui ignorera le reste du code (tant que "p" et "s" sont équilibrés. La ligne pertinente pour SIL / SILOS est "print Hola Mundo" et le code brainfuck est à la fin et ignorera le reste du code.

5 langues, 213 octets

J'ai décidé d'essayer d'écrire une petite réponse moi-même.

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

Langues:

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 et C ++ voient le code comme:

#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;est (en effet) égal à int i=0;C, mais égal à double i=0.5;C ++.

Essayez-le en ligne! (comme C)

Essayez-le en ligne! (en C ++)

Python 3 voit le code comme:

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

Essayez-le en ligne!

Le langage de script OFP voit:

; (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 fission voit:

R "Pozdrav svijete!";

Essayez-le en ligne!

3 langues, 184 181 octets

Ne fonctionne qu'une seule fois - vous devez effacer la liste pour la réexécuter.

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 à partir du moment de cette réponse: Hai dunia!

Explication

Dans Scratch 1.4, l'ajout d'un booléen à une liste ajoute 1ou 0, mais dans les versions 2.0 et supérieures, il ajoute trueou false, mais lorsque vous vérifiez si l'élément est égal à 1avec <[] = []>, il renvoie true si l'élément est un 1ou true, nous ajoutons donc une autre lettre et vérifions cela.

Dans Scratch 3.0, les listes ont une taille maximale de 200 000 éléments. Nous ajoutons donc un grand nombre d’éléments et voyons si la liste est aussi longue.

3 langues, 61 octets

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

Ajouter ++ sortiesHai dunia!

Sorties de geléeHello World!

Foo sortiesHelo Byd!

Ce n’est pas parce que j’ai réglé la prime que je ne peux pas participer: D (ab) utilise la brillante astuce que Conor a trouvée pour Add ++

Comment ça fonctionne

Ajouter ++

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

Les commentaires dans Jelly peuvent être formés avec la syntaxe ḷ“comment”, c'est-à-dire que le code Add ++ et Foo est ignoré. Le code qui est réellement exécuté par Jelly est

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

Foo

Foo ignore tous les caractères ici, sauf ceux "Helo Byd!"qui, comme ils sont entre guillemets, sont affichés.