Aufgabe

Erstellen Sie ein Programm oder eine Funktion, die in mehreren Programmiersprachen gültig ist und bei Kompilierung / Interpretation in einer anderen Sprache "Hallo, Welt!" in einer anderen natürlichen Sprache.

Beispielsweise kann eine gültige Lösung Hello World!beim Kompilieren und Ausführen als C (Englisch), Hallo Welt!beim Kompilieren und Ausführen als C ++ (Deutsch) und 你好世界！beim Ausführen als Python (Chinesisch) ausgeben .

Regeln

Um Unklarheiten über die Gültigkeit einer Antwort zu vermeiden, finden Sie nachfolgend eine Liste der zulässigen Versionen des Ausdrucks in mehreren Sprachen. Die Liste besteht aus der Phrase in Sprachen, für die Google Translate eine von der Community überprüfte Übersetzung der Phrase hat (zum Zeitpunkt dieses Schreibens). *

Die Genauigkeit dieser Übersetzungen ist umstritten, aber diese Herausforderung wird sie nutzen. Die gedruckten Zeichenfolgen müssen genau dem unten angegebenen Format entsprechen (mit Ausnahme von führenden oder nachfolgenden Leerzeichen).

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!

Es gibt also 74 Sprachen, die verwendet werden können.

Gewinnkriterium

Die Lösung, die die Phrase in der größten Anzahl von Sprachen ausgeben kann, gewinnt. Bei Gleichstand gewinnt die kürzere Lösung (in Bytes).

_{* Die Übersetzungen für Madagassisch und Maltesisch wurden von der Community als verifiziert markiert, waren jedoch eindeutig falsch (eine war nur "Hello World!" Und die andere "Hello Dinja!", Aber "Hello!" Allein bedeutet "Bongu!"). Diese wurden ausgeschlossen. Auch einige Sprachen (Arabisch, Hebräisch, Paschtu, Persisch und Jiddisch) lesen bei Google Translate von rechts nach links, aber wenn sie hier kopiert werden, lesen sie von links nach rechts. Ich hoffe das ist okay.}

23 Befunges, 713 Bytes

Die einzige Sprache, die ich wirklich kenne, ist Befunge. Statt mehrerer Sprachen habe ich jetzt mehrere Befunge-Implementierungen verwendet. Ich bin der Meinung, dass dies nach den PPCG-Regeln immer noch gültig ist, da diese davon ausgehen, dass die Sprache durch ihre Implementierung definiert wird .

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

Das Frustrierende an Befunge ist, dass es, obwohl es eine Open-Source-Referenzimplementierung gibt und die Sprache selbst absolut einfach ist, keinen einzigen Interpreter von Drittanbietern gibt (dessen ich mir bewusst bin), der genau mit dem Referenzverhalten übereinstimmt. Jede Implementierung schlägt anders fehl.

Positiv zu vermerken ist, dass wir die Möglichkeit haben, einen einzigen Code zu entwickeln, der für fast jeden Interpreter ein anderes Ergebnis liefert. Und genau das versuche ich im obigen Programm.

Wenn jemand Interesse daran hat, die Ergebnisse zu überprüfen, habe ich versucht, die verschiedenen Implementierungen in Kategorien zu gruppieren, die darauf basieren, wie einfach sie einzurichten sind (z. B. können manche Benutzer möglicherweise keine Windows-Binärdateien ausführen oder sind möglicherweise nicht dazu bereit) aus dem Quellcode erstellen, aber jeder sollte in der Lage sein, die Online-Dolmetscher zu testen).

Online-Dolmetscher

Keine Installation erforderlich. In der Regel müssen Sie nur den Code einfügen und auf eine oder zwei Schaltflächen klicken. Beachten Sie jedoch, dass einige dieser Vorgänge sehr langsam sind. Daher kann es einige Zeit dauern, bis die Ausführung abgeschlossen ist.

Klicken Sie auf die Clear...Schaltfläche und fügen Sie den Code in das Eingabefeld ein. EditSchalten Sie den Schalter um, um den Interpreter zu aktivieren, und klicken Sie dann auf die RunSchaltfläche, um mit der Ausführung zu beginnen.
Beachten Sie, dass diese Site in anderen Browsern als Chrome wahrscheinlich nicht funktioniert.

Fügen Sie den Code in das Eingabefeld ein und achten Sie darauf, den vorhandenen Code zu überschreiben. Klicken Sie dann Runzum Ausführen auf die Schaltfläche.

Fügen Sie den Code in das Spielfeld Eingabefeld, und klicken Sie dann auf die RunSchaltfläche Ausführung beginnen.

Fügen Sie den Code in das Eingabefeld unter der ShowSchaltfläche ein und achten Sie darauf, den @bereits vorhandenen Code zu überschreiben . Klicken Sie auf die ShowSchaltfläche, um den Code zu importieren, und klicken Sie dann auf die RunSchaltfläche, um mit der Ausführung zu beginnen.

Schließen Sie zuerst die Hilfe Dialog und klicken Sie auf die Öffnen / Import Symbolleiste auf die Schaltfläche (zweiter von links), Paste in den Code, und klicken Sie auf OK. Klicken Sie zum Ausführen auf die Schaltfläche Run Mode (vierter von links) und dann auf Start (fünfter von links).

Beachten Sie auch, dass einige der konsolenbasierten Interpreter tatsächlich auf TIO verfügbar sind. Sie sind also keine technischen Online-Interpreter, sondern können online getestet werden. Für diejenigen, die unterstützt werden (derzeit BEF, FBBI, MTFI und PyFunge), habe ich Try It Online! Link neben ihrem Eintrag.

Java IDEs

Sie müssen die Java-Laufzeit für diese installiert haben, aber sie sollten theoretisch auf jeder Plattform funktionieren. Nur unter Windows getestet.

Dies war ursprünglich ein Online-Applet, das leider nicht mehr verfügbar ist, aber Sie können die JAR-Datei trotzdem herunterladen und lokal als Desktop-Anwendung ausführen. Sie müssen den Code in das Programmeditorfenster einfügen und dann auf die ConvertSchaltfläche und anschließend auf die RunSchaltfläche klicken .

Um den Code einzufügen, klicken Sie mit der rechten Maustaste in die obere linke Ecke des Editorfensters (es muss ganz oben links sein) und wählen Sie den Menüpunkt Einfügen . Aktivieren Sie dann das Kontrollkästchen Full Speed (andernfalls dauert es ewig) und klicken Sie auf die Run!Schaltfläche, um mit der Ausführung zu beginnen.

Drücken Sie Ctrl+ A, Ctrl+, Vum den Code in das Editorfenster einzufügen und die Standardquelle zu überschreiben. Klicken Sie dann auf die StartSchaltfläche, um mit der Ausführung zu beginnen.

Windows-IDEs

In der Regel benötigen Sie hierfür Windows. In einigen Fällen sind jedoch Binärdateien für andere Betriebssysteme verfügbar. Ich kann nicht versprechen, dass der Code auf anderen Plattformen funktioniert.

Sie können den Code nicht in den Editor einfügen, daher müssen Sie ihn zunächst irgendwo auf der Festplatte speichern. Verwenden Sie dann in der IDE das Menü Datei> Öffnen , um den Code von der Festplatte zu laden, und wählen Sie das Menü Simulation> Ausführen / Pause , um ihn auszuführen.

Drücken Sie Ctrl+, Vum den Code einzufügen , und klicken Sie dann in der Symbolleiste auf die Schaltfläche Debuggen (das blaue Zahnrad), um mit der Ausführung zu beginnen. Sobald der Debugger-Bereich angezeigt wird, möchten Sie die Geschwindigkeit auf Maximum einstellen - die Schaltfläche rechts neben dem Schieberegler - andernfalls dauert es ewig, bis der Vorgang abgeschlossen ist.

Drücken Sie Ctrl+ Vin den Code einzufügen, und drücken Sie dann F5, um sie auszuführen.

Sie können den Code nicht in den Editor einfügen, daher müssen Sie ihn zunächst irgendwo auf der Festplatte speichern. Drücken Sie dann in der IDE Ctrl+ O, um den Dateibrowser zu öffnen und den Code von der Festplatte zu laden, und drücken Sie F5, um ihn auszuführen.

Windows-Konsolen-Apps

Wiederum erfordern diese normalerweise Windows, obwohl andere Plattformen möglicherweise verfügbar sind, aber nicht garantiert funktionieren.

In allen Fällen muss der Code in einer Datei auf der Festplatte gespeichert und der Dateiname als Befehlszeilenparameter an den Interpreter übergeben werden ( source.bf in den folgenden Beispielbefehlszeilen). Beachten Sie auch, dass einige dieser Interpreter technisch Befunge-98-Interpreter sind und mit einer bestimmten Befehlszeilenoption ausgeführt werden müssen, um einen Befunge-93-Kompatibilitätsmodus zu erzwingen. Wenn Sie das nicht tun, erhalten Sie nicht die richtigen Ergebnisse.

Befehlszeile: bef93w32 -q source.bf

Befehlszeile: ccbi --befunge93 source.bf

Befehlszeile: mtfi -3 source.bf( Online ausprobieren! )

Python- und PHP-Konsolen-Apps

Hierfür muss die entsprechende Skriptsprache installiert sein - entweder Python oder PHP.

Befehlszeile: befungee.py source.bf

Befehlszeile: pyfunge -v 93 source.bf( Online ausprobieren! )

Befehlszeile: php bephunge.phps source.bf

Nur-Quell-Konsolen-Apps

Diese müssen aus dem Quellcode erstellt werden, und das ist normalerweise am einfachsten in einer * nix-ähnlichen Umgebung. Unter Windows verwende ich das Windows-Subsystem für Linux .

Befehlszeile: bef -q source.bf( Online ausprobieren! )

Befehlszeile: cfunge -s 93 source.bf

Befehlszeile: fbbi -93 source.bf( Online ausprobieren! )

Befehlszeile: fungi source.bf

Befehlszeile: rcfunge -93 source.bf

Wie es funktioniert

Die Herausforderung dabei war, die geringste Anzahl von Tests zu finden, die die größte Differenzierung zwischen Dolmetschern ermöglichten. Am Ende waren es vier Haupttestsequenzen:

1. Der erste ist ein Speicher außerhalb der Grenzen, der von Offset -1,1 gelesen wird. Theoretisch sollte dies immer 32 (ASCII-Raum) zurückgeben, aber in der Praxis gab es tatsächlich 10 Variationen. Dieser Test wird durch die Tatsache erschwert, dass zwei der Interpreter bei einer Lesung außerhalb der Grenzen abstürzen. Daher waren einige Spezialfalltests (Division Rounding und Space Bridging) erforderlich, um diese beiden zurück in die Schranken zu zwingen.

2. Die zweite Sequenz ist ein Test der Befunge-98-Funktionalität - speziell der Anweisungen ;und '. Fast alle Interpreter sind Befunge-93-Interpreter oder werden im Befunge-93-Kompatibilitätsmodus ausgeführt. Sie sollten diese Anweisungen einfach ignorieren. In der Praxis gab es 6 verschiedene Arten, wie diese Reihenfolge interpretiert wurde.

3. Der dritte Test überprüft den Bereich der Speicherzellen. In dem Referenzinterpreter sind Speicherzellen 8-Bit mit Vorzeichen versehen, aber andere Implementierungen variieren im Bereich von 8-Bit bis unbegrenzt, einige mit Vorzeichen und einige ohne Vorzeichen. Für diesen Test mussten wir jedoch nur zwischen 5 dieser Varianten unterscheiden.

4. Die vierte und letzte Sequenz ist eine Kombination aus Unterlauf- und Negativuntertests. Es gibt eine Reihe von Möglichkeiten, wie Interpreter falsch unterlaufen, und es gibt mindestens 3 verschiedene Möglichkeiten, wie die Divisions- und Modulo-Anweisungen implementiert werden, aber es gab nur 3 Kombinationen, die uns hier wichtig waren.

Jede dieser Sequenzen gab eine einzelne Zahl zurück, und diese vier Zahlen wurden (über einige Grundrechen- und Übersetzungstabellen) kombiniert, um einen Endwert im Bereich von 0 bis 22 zu erhalten. Dieser Wert könnte dann als Index zum Nachschlagen der tatsächlichen Nachricht verwendet werden anzuzeigen.

16 Sprachen, 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!?%?"

Probieren Sie es online!

(Benutzen Sie "switch languages" um die Sprache zu ändern)

• Python 3 = Halo Dunia! (Indonesisch)

• Python 2 = Hej Verden! (Dänisch)

• Python 1 = Hai Dunia! (Malaiisch)

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

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

• Ziel C (clang) = Hallo Welt! (Deutsche)

• Brainfuck = Hallo Welt! (Englisch, offensichtlich)

• Befunge-93 = Salut Lume! (Rumänisch)

• Ruby = Moien Welt! (Luxemburgisch)

• Bash = Salom Dunyo! (Usbekisch)

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

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

• Kardinal = Hallo Wereld! (Niederländisch)

• Alphuck = Ciao Mondo! (Italienisch)

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

• Fission = Pozdrav svijete! (Kroatisch)

Alle Golftipps sind willkommen (besonders auf dem Brainfuck) !!

Vielen Dank an @ JonathanFrech für -1 Byte! Danke auch an @ovs für -40 Bytes!

Wie (allgemeine Vorstellungen, ich habe eigentlich Einzelheiten vergessen) ??

Die Sprachen können in vier Gruppen eingeteilt werden:

• Makro: C, C ++, Ziel C
• Kommentar: Python3, Python2, Python1, Ruby, Bash
• Dimension: Befunge-93, Befunge-98, Unefunge-98, Kardinal,> <>, Spaltung
• Vulgar: Brainfuck, Alphuck

Die Makrosprachen gelten #als Start einer Präprozessor-Direktive. Diese werden aus drei Gründen verwendet: um Code für andere Gruppen unterzubringen, zwischen Makrosprachen zu unterscheiden und tatsächlich ein Makro zu definieren. Alle drei werden //als Kommentar verwendet. Danach speichern wir Code für die anderen Gruppen. Außerdem setzt der Backslash den Kommentar in diesen Sprachen fort.

Die Kommentarsprachen werden #als Beginn eines Kommentars angesehen. Die Besonderheit hier sind die dreifachen Anführungszeichen, die die Pythons von Ruby von Bash unterscheiden. Und um Python 1 von 2 von 3 zu unterscheiden, verwenden wir in allen drei Fällen ein Unterscheidungsmerkmal sowie eine Reihe von Ausgaben. Oh ja, das gibt es auch __END__. Dies wird verwendet, um den Code für einige (ich kann mich nicht genau an welche erinnern) der Kommentarsprachen zu beenden.

Die Dimensionssprachen werden auf eine Weise unterschieden, die schwer zu erklären ist. Man muss die Besonderheiten jeder Sprache kennen, um es herauszufinden. Zum Beispiel #ist es nur ein Sprung in den Fungeoids, während es in den anderen Sprachen verschiedene Dinge tut. Der Code ist für diese Sprachen überall verstreut.

Und schließlich kommen wir zu den vulgären Sprachen. Diese beiden ignorieren alles, was nicht in ihren gültigen Zeichen enthalten ist. Mit diesen und den anderen Sprachen muss ein Balanceakt gespielt werden, da der Code bereits Zeichen in den Zeichensätzen enthält.

15 Sprachen, 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+++[++[<+++>->+++<]>+++++++]<<<--.<.<--..<<---.<+++.<+.>>.>+.>.>-.<<<<+.
   	  	   
	
     		  	 	
	
     		 		  
	
     		 				
	
     	     
	
     	    	 
	
     				  	
	
     		  	  
	
     	    	
	
  

Probieren Sie es online!

1. Kaixo Mundua! in Befunge-93
2. Hej Verden! in Fission
3. Tere maailm! in Unefunge-98
4. Hei maailma!! in Befunge-98
5. Hai dunia! in> <>
6. Hola món! in Ruby
7. Hola Mundo! in GolfScript
8. Hallo Welt! in bash
9. Ndewo Ụwa! in ksh
10. Ciao mondo! in Strich
11. Moien Welt! in zsh
12. Hei Verden! in Asche
13. Olá Mundo! in Cardinal
14. Hello World!Mit freundlicher Genehmigung von Primo .
15. Helo Byd! in Whitespace

Erläuterung

Zeile 1 unterscheidet fünf 2D-Esolangs:

1. ><>liest sich #wie ein Spiegel, wickelt sich nach links um, druckt "Hai dunia!"und stürzt ab ( @). Alle Funges lesen es als Trampolin und gehen nach rechts.
2. Befunge-93 ignoriert ;, druckt Kaixo Mundua!und beendet ( @).
3. Die 98er Funges springen von der ersten ;zur zweiten, dann von der dritten ;zur vierten. wist ein NOP für Befunge-98, Drucken Hei maailma!.
4. Aber wspiegelt den Befehlszeiger in Unefunge-98, Drucken Tere maailm!.
5. Die Spaltung beginnt überhaupt nicht in der oberen linken Ecke. R"Hej Verden!";ausgeführt wird. (Ein weiterer Befehlszeiger geht davon aus , Din __END__, aber es tut nichts stirbt dann an die ;in true;.)

Ruby sieht `true #{puts'Hola món!'}`dann __END__.

GolfScript sieht `dann true(NOP), dann einen Kommentar; dann __END__(NOP); dann "Hola Mundo!" puts(dies wird ausgeführt); dann case(NOP), dann `(stürzt bei leerem Stack ab).

Die Shells sehen einen Kommentar, dann einen Aufruf an true(NOP), dann Aufrufe an unbekannte Befehle __END__und "Hola Mundo!"(welcher Fehler an STDERR, aber die Ausführung wird fortgesetzt) ​​dann die caseAnweisung, die anhand des ersten Buchstabens des Namens des aktuellen Prozesses unterscheidet.

Cardinal ist ein weiterer 2D-Esolang, der mit dem %Senden von 4 IPs nach oben, unten, links und rechts beginnt . Sie werden alle von den umliegenden xBefehlen getötet, aber einer druckt, "Olá Mundo!"bevor er stirbt.

Der Brainfuck-Code ist der Primo-Code, der vorangestellt wird ++, um den Strichen entgegenzuwirken ps -p$$ -oargs=.

Das Leerzeichen in meinem Code wird als Whitespace-Programm ausgeführt

 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

welche druckt Helo Byd!

BEARBEITEN : Ich habe vergessen, dass das Hinzufügen von UDLRZeichen das Fission-Programm bricht. Deshalb habe ich die Zeichenfolgen geändert, um diese zu vermeiden.

4 Sprachen, 75 Bytes

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

Python -Hai dunia!

Perl -Helo Byd!

Rubin -Hola món!

Heuhaufen -Hej Verden!

7 Sprachen, 221 Bytes

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

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

Da dieses Programm einige unangenehme Zeichen enthält, ist hier ein 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ë!- Online ausprobieren !
• Befunge-98 Abzüge Hallo Wereld!- Probieren Sie es online!
• Trefunge-98-Abzüge ሰላም ልዑል!- Online testen !
• Tatsächlich druckt Hello Wêreld!- Probieren Sie es online!
• Bash Prints Kaixo Mundua!- Online ausprobieren!
• PHP druckt مرحبا بالعالم!- Probieren Sie es online!
• Retina Drucke Բարեւ աշխարհ!- Probieren Sie es online!

5 Sprachen, 168 Bytes

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

Ich finde zweidimensionale Sprachen interessant.

> <> druckt Tere maailm!
Befunge-98 druckt Hej Verden!
Bienenwachs druckt Sawubona Mhlaba!
Kardinal druckt Helo Byd!
Fission drucktHello World!

Probieren Sie es online! (Kardinal)

2 Sprachen, 16 Zeichen, 24 Bytes

Zumindest ist das kürzer als beide Saiten.

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

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

Hilfe, WarDoq! -Hello World!

_{Hilfe, WarDoq! kann zwei Zahlen addieren und auf Primzahlen testen, daher wird es als gültige Programmiersprache für diesen Metapost angesehen .}

3 Sprachen, 67 62 Bytes

Um sich für dieses Kopfgeld zu qualifizieren (100 Wiederholungen).

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

Add ++: Probieren Sie es online!

Foo: Probieren Sie es online!

Somme: Online ausprobieren!

Erläuterung

++ hinzufügen

Add ++ sieht:

x:Helo Byd!
O

" xString der Ausgabe "

y:"Hai dunia!"

"Setze y auf einen anderen String"

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

"Idk etwas komisch, ich werde Fehler aus"

Foo

Foo sieht:

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

"Oo, Zitate, die gebe ich aus."

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

"Äh ... irgendwas über einen Modus? Idk, ich werde Fehler machen."

Somme

Somme sieht nun das:

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

Jede Spalte wird in Codepunkte umgewandelt, dann werden 32 von diesen abgezogen, dann wird jedes Modulo 95 genommen. Dies entspricht diesen Zeichen, die "Hei Verden!"

4 Sprachen, 138 Bytes

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

Probieren Sie es online!

Py1, Py2, Py3, Proton; danke an Mr. Xcoder; übersetzt aus Zacharýs Antwort

4 Sprachen, 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 gibt Hallo Wereld!- TIO

Ruby gibt Hello World!- TIO

Python 2 gibt Hej Verden!- TIO

Python 3 gibt Hei Verden!- TIO

Vier Sprachen, satte 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 gibt "Salut Lume!" Versuch es!

SILOS gibt "Hola Mundo" Probieren Sie es aus!

Brainfuck gibt "Ciao Mondo!" Versuch es!

(Der Alphuck-Code wurde auf der Esolangs-Seite von Alphuck geändert. )

Alphuck gibt "Hallo Welt!" Versuch es!

Die Zeile, die mit \ u000A beginnt, ist der Java-Code. Der Code in Zeile 1 ist der Alphuck-Code, der den Rest des Codes ignoriert (solange "p" und "s" ausgeglichen sind. Die relevante Zeile für SIL / SILOS ist "print Hola Mundo" und der Brainfuck-Code ist am Ende und ignoriert den Rest des Codes.

5 Sprachen, 213 Bytes

Ich beschloss, selbst eine kleine Antwort zu schreiben.

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

Sprachen:

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 und C ++ sehen den Code als:

#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;ist (in der Tat) gleich int i=0;in C, aber gleich double i=0.5;in C ++.

Probieren Sie es online! (als C)

Probieren Sie es online! (als C ++)

Python 3 sieht den Code als:

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

Probieren Sie es online!

OFP- Skriptsprache sieht:

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

Fission sieht:

R "Pozdrav svijete!";

Probieren Sie es online!

3 Sprachen, 184 181 Bytes

Funktioniert nur einmal - Sie müssen die Liste löschen, um sie erneut auszuführen.

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 zum Zeitpunkt dieser Antwort: Hai dunia!

Erläuterung

Wenn Sie in Scratch 1.4 einen Booleschen Wert zu einer Liste hinzufügen, wird 1oder hinzugefügt. 0In 2.0 und höher wird jedoch trueoder hinzugefügt. falseWenn Sie jedoch überprüfen, ob das Element 1mit <[] = []> übereinstimmt, wird true zurückgegeben, wenn das Element entweder 1oder ist true, also fügen wir einen weiteren Buchstaben hinzu und prüfen das.

In Scratch 3.0 haben Listen eine maximale Größe von 200.000 Elementen. Daher fügen wir nur eine Reihe von Elementen hinzu und prüfen, ob die Liste so lang ist.

3 Sprachen, 61 Bytes

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

++ Ausgänge hinzufügenHai dunia!

Gelee- AusgängeHello World!

Foo AusgängeHelo Byd!

Nur weil ich das Kopfgeld gesetzt habe, heißt das nicht, dass ich nicht teilnehmen kann: D (ab) verwendet den brillanten Trick zum Setzen von Strings, den Conor für Add ++ gefunden hat

Wie es funktioniert

++ hinzufügen

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

Gelee

Kommentare in Jelly können mit der Syntax gebildet werden, bei der ḷ“comment”der Add ++ - und Foo-Code ignoriert wird. Der Code, der tatsächlich von Jelly ausgeführt wird, ist

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

Foo

Foo ignoriert hier bis auf alle Zeichen "Helo Byd!", die, wie in Anführungszeichen angegeben, ausgegeben werden.