Compito

Crea un programma o una funzione valida in più linguaggi di programmazione e quando compilato / interpretato come un linguaggio diverso genera "Hello, World!" in un diverso linguaggio naturale.

Ad esempio, una soluzione valida potrebbe generare Hello World!(inglese) quando compilato ed eseguito come C, Hallo Welt!(tedesco) quando compilato ed eseguito come C ++ e 你好世界！(cinese) quando eseguito come Python.

Regole

Per evitare ambiguità sulla validità di una risposta, di seguito è riportato un elenco di versioni consentite della frase in diverse lingue. L'elenco è composto dalla frase in lingue per cui Google Translate ha una traduzione verificata dalla comunità della frase (al momento della stesura di questo documento). *

L'accuratezza di queste traduzioni è discutibile, ma sono ciò che questa sfida utilizzerà. Le stringhe stampate devono seguire esattamente il formato seguente (ad eccezione degli spazi bianchi iniziali o finali).

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!

Quindi ci sono 74 lingue che possono essere utilizzate.

Criterio vincente

Vince la soluzione che può produrre la frase nel maggior numero di lingue. In caso di pareggio, vince la soluzione più breve (in byte).

_{* Le traduzioni per malgascio e maltese sono state contrassegnate come verificate dalla comunità, ma erano chiaramente errate (una era solo "Hello World!" E l'altra "Hello dinja!", Ma "Hello!" Da solo si traduce in "Bongu!"). Questi sono stati esclusi. Anche alcune lingue (arabo, ebraico, pashto, persiano e yiddish) leggono da destra a sinistra su Google Translate, ma una volta copiate qui leggono da sinistra a destra. Spero vada bene.}

23 Befunges, 713 byte

L'unica lingua che conosco davvero è Befunge, quindi al posto di più lingue, ho appena scelto diverse implementazioni di Befunge. Credo che ciò sia ancora valido in base alle regole PPCG, che considerano il linguaggio definito dalla sua implementazione .

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

La cosa frustrante di Befunge è che sebbene ci sia un'implementazione di riferimento open source e il linguaggio stesso sia completamente semplice, non esiste un singolo interprete di terze parti (di cui sono a conoscenza) che corrisponda esattamente al comportamento di riferimento. Ogni implementazione fallisce in modo diverso.

Tra i lati positivi, questo ci dà l'opportunità di sviluppare un singolo pezzo di codice che produrrà un risultato diverso in quasi tutti gli interpreti. Ed è quello che sto tentando nel programma sopra.

Se qualcuno è interessato a verificare i risultati, ho provato a raggruppare le varie implementazioni in categorie in base a quanto sono facili da avviare e da eseguire (ad esempio alcune persone potrebbero non essere in grado di eseguire i binari di Windows o potrebbero non essere disposti a compilare dalla fonte, ma tutti dovrebbero essere in grado di testare gli interpreti online).

Interpreti online

Nessuna installazione richiesta. Di solito è solo una questione di incollare il codice e fare clic su uno o due pulsanti. Ma nota che alcuni di questi sono piuttosto lenti, quindi potrebbe essere necessario del tempo per terminare l'esecuzione.

Fare clic sul Clear...pulsante e incollare il codice nel campo di input. Attiva l' Editinterruttore per attivare l'interprete, quindi fai clic sul Runpulsante per iniziare l'esecuzione.
Si noti che questo sito probabilmente non funzionerà nel browser diverso da Chrome.

Incolla il codice nel campo di input, assicurandoti di sovrascrivere il codice esistente. Quindi fare clic sul Runpulsante per eseguire.

Incolla il codice nel campo di input di Playfield , quindi fai clic sul Runpulsante per iniziare l'esecuzione.

Incolla il codice nel campo di input sotto il Showpulsante, assicurandoti di sovrascrivere quello @che è già lì. Fare clic sul Showpulsante per importare il codice, quindi fare clic sul Runpulsante per iniziare l'esecuzione.

Prima chiudi la finestra di dialogo Guida , quindi fai clic sul pulsante Apri / Importa sulla barra degli strumenti (secondo da sinistra), incolla il codice e fai clic OK. Per eseguire, fare clic sul pulsante Modalità di esecuzione (quarto da sinistra), quindi su Avvio (quinto da sinistra).

Inoltre, alcuni interpreti basati su console sono effettivamente disponibili su TIO, quindi, sebbene non siano tecnicamente interpreti online, possono essere testati online. Per quelli che sono supportati (attualmente BEF, FBBI, MTFI e PyFunge), ho incluso un Prova online! link accanto alla loro voce.

IDE Java

Dovrai avere il runtime Java installato per questi, ma dovrebbero teoricamente funzionare su qualsiasi piattaforma. Testato solo su Windows però.

Inizialmente si trattava di un'applet online che purtroppo non è più disponibile, ma è comunque possibile scaricare il vaso ed eseguirlo localmente come applicazione desktop. Dovrai incollare il codice nella finestra dell'Editor di programmi , quindi fare clic sul Convertpulsante, seguito dal Runpulsante.

Per incollare il codice, fai clic con il tasto destro nell'angolo in alto a sinistra della finestra dell'editor ( deve essere in alto a sinistra) e seleziona la voce di menu Incolla . Quindi abilitare la casella di controllo Velocità massima (altrimenti ci vorrà per sempre) e fare clic sul Run!pulsante per iniziare l'esecuzione.

Premi Ctrl+ A, Ctrl+ Vper incollare il codice nella finestra dell'editor, assicurandoti di sovrascrivere la fonte predefinita. Quindi fare clic sul Startpulsante per iniziare l'esecuzione.

IDE di Windows

Di solito avrai bisogno di Windows per questi, anche se in alcuni casi potrebbero essere disponibili file binari per altri sistemi operativi. Non posso promettere che il codice funzionerà su altre piattaforme però.

Non è possibile incollare il codice nell'editor, quindi è necessario prima salvarlo su disco da qualche parte. Quindi, dall'IDE, utilizzare il menu File> Apri per caricare il codice dal disco e selezionare il menu Simulazione> Esegui / Pausa per eseguirlo.

Premi Ctrl+ Vper incollare il codice, quindi fai clic sul pulsante della barra degli strumenti Debug (la ruota dentata blu) per iniziare l'esecuzione. Una volta visualizzato il pannello Debugger , ti consigliamo di impostare la velocità al massimo - il pulsante a destra del cursore - altrimenti ci vorrà un'eternità per finire.

Premere Ctrl+ Vper incollare il codice, quindi premere F5per eseguirlo.

Non è possibile incollare il codice nell'editor, quindi è necessario prima salvarlo su disco da qualche parte. Quindi dall'IDE, premere Ctrl+ Oper aprire il browser dei file e caricare il codice dal disco, quindi premere F5per eseguirlo.

App della console di Windows

Anche in questo caso in genere richiedono Windows, anche se potrebbero essere disponibili altre piattaforme, ma non sono garantite per funzionare.

In tutti i casi il codice dovrà essere salvato su un file su disco e il nome del file sarà passato all'interprete come parametro della riga di comando ( source.bf nelle righe di comando di esempio fornite di seguito). Si noti inoltre che alcuni di questi sono tecnicamente interpreti di Befunge-98 e devono essere eseguiti con una particolare opzione della riga di comando per forzare una modalità di compatibilità di Befunge-93. Se non lo fai, non otterrai i risultati corretti.

Riga di comando: bef93w32 -q source.bf

Comand line: ccbi --befunge93 source.bf

Riga di comando: mtfi -3 source.bf( Provalo online! )

App per console Python e PHP

Questi richiedono il linguaggio di scripting appropriato installato - Python o PHP.

Riga di comando: befungee.py source.bf

Riga di comando: pyfunge -v 93 source.bf( Provalo online! )

Riga di comando: php bephunge.phps source.bf

App console solo di origine

Questi dovranno essere creati dal sorgente, e di solito è più semplice con un ambiente simile a * nix. Su Windows utilizzo il sottosistema Windows per Linux .

Riga di comando: bef -q source.bf( Provalo online! )

Riga di comando: cfunge -s 93 source.bf

Riga di comando: fbbi -93 source.bf( Provalo online! )

Riga di comando: fungi source.bf

Riga di comando: rcfunge -93 source.bf

Come funziona

La sfida con questo era trovare il minor numero di test che fornivano il maggior grado di differenziazione tra interpreti. Alla fine si è trattato di quattro sequenze di test principali:

1. La prima è una memoria fuori limite letta dall'offset -1,1. In teoria questo dovrebbe sempre restituire 32 (spazio ASCII), ma in realtà c'erano 10 variazioni nella pratica. Questo test è complicato dal fatto che due degli interpreti si bloccano su una lettura fuori limite, quindi sono stati necessari un paio di test per casi speciali (arrotondamento delle divisioni e ponte spaziale) per forzare questi due limiti.

2. La seconda sequenza è un test della funzionalità di Befunge-98, in particolare le istruzioni ;e '. Quasi tutti gli interpreti sono Befunge-93 o sono eseguiti in modalità di compatibilità Befunge-93, quindi dovrebbero semplicemente ignorare quelle istruzioni. In pratica c'erano 6 diversi modi in cui questa sequenza è stata interpretata.

3. Il terzo test controlla l'intervallo di celle di memoria. Nell'interprete di riferimento, le celle di memoria sono firmate a 8 bit, ma altre implementazioni variano nell'intervallo da 8 bit a illimitato, alcune con segno e altre senza segno. Tuttavia, ai fini di questo test, abbiamo dovuto solo distinguere tra 5 di quelle varianti.

4. La quarta e ultima sequenza è una combinazione di underflow e test di divisione negativa. Esistono diversi modi in cui gli interpreti sbagliano il underflow e ci sono almeno 3 modi diversi in cui vengono implementate le istruzioni di divisione e modulo, ma c'erano solo 3 combinazioni a cui tenevamo qui.

Ognuna di queste sequenze ha restituito un singolo numero e quei quattro numeri sono stati combinati (tramite alcune tabelle aritmetiche e di traduzione di base) per produrre un valore finale nell'intervallo da 0 a 22. Tale valore potrebbe quindi essere utilizzato come indice per cercare il messaggio effettivo da visualizzare.

16 lingue, 1363 byte

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

Provalo online!

(usa "cambia lingua" per cambiare lingua)

• Python 3 = Halo Dunia! (Indonesiano)

• Python 2 = Hej Verden! (Danese)

• Python 1 = Hai dunia! (Malese)

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

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

• Obiettivo C (clang) = Hallo Welt! (Tedesco)

• Brainfuck = Hello World! (Inglese, ovviamente)

• Befunge-93 = Salut Lume! (Rumeno)

• Ruby = Moien Welt! (Lussemburghese)

• Bash = Salom Dunyo! (Uzbeko)

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

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

• Cardinale = Hallo Wereld! (Olandese)

• Alphuck = Ciao mondo! (Italiano)

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

• Fissione = Pozdrav svijete! (Croato)

Tutti i suggerimenti per il golf sono i benvenuti (specialmente sul Brainfuck) !!

Grazie a @JonathanFrech per -1 byte! Inoltre, grazie a @ovs per -40 byte!

Come (idee generali, in realtà ho dimenticato i dettagli) ??

Le lingue possono essere suddivise in quattro gruppi:

• Macro: C, C ++, Obiettivo C
• Commento: Python3, Python2, Python1, Ruby, Bash
• Dimensionale: Befunge-93, Befunge-98, Unefunge-98, Cardinale,> <>, Fissione
• Volgare: Brainfuck, Alphuck

I linguaggi Macro sono visti #come l'inizio di una direttiva preprocessore. Questi sono usati per tre motivi: ospitare il codice per altri gruppi, distinguere tra i linguaggi Macro e definire effettivamente una macro. Tutti e tre usano //come commento, quindi dopo memorizziamo il codice per gli altri gruppi. Inoltre, la barra rovesciata continua il commento in queste lingue.

Le lingue dei commenti vengono visualizzate #come l'inizio di un commento. La stranezza qui sono le triple virgolette, che distinguono i pitoni da Ruby da Bash. E per distinguere Python 1 da 2 da 3, utilizziamo una caratteristica distintiva in tutti e tre, insieme a una matrice di output. Oh sì, c'è anche quello __END__. Questo è usato per terminare il codice per alcune (non ricordo esattamente quali) le lingue dei commenti.

Le lingue dimensionali si distinguono in un modo che è difficile da spiegare. Bisogna conoscere i dettagli di ogni lingua per capirlo. Ad esempio, #è solo un salto nei fungeoidi, mentre fa diverse cose nelle altre lingue. Il codice è sparso ovunque per queste lingue.

E infine, arriviamo alle lingue volgari. Questi due ignorano tutto ciò che non è nel loro set di caratteri validi. Un atto di bilanciamento deve essere giocato con queste lingue e le altre, poiché il codice contiene già caratteri nei set di caratteri.

15 lingue, 532 byte

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

Provalo online!

1. Kaixo Mundua! in Befunge-93
2. Hej Verden! in Fissione
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 trattino
11. Moien Welt! in zsh
12. Hei Verden! in frassino
13. Olá Mundo! nel cardinale
14. Hello World!in brainfuck, per gentile concessione di primo .
15. Helo Byd! nello spazio bianco

Spiegazione

La linea 1 distingue tra cinque esolang 2D:

1. ><>legge #come uno specchio, si avvolge a sinistra, stampa "Hai dunia!"e si arresta in modo anomalo ( @). Tutti i funghi lo leggono come un trampolino e vanno a destra.
2. Befunge-93 ignora ;, stampa Kaixo Mundua!ed esce ( @).
3. I Funghi del '98 saltano dal primo ;al secondo, quindi dal terzo ;al quarto. wè un NOP per Befunge-98, in stampa Hei maailma!.
4. Ma wriflette il puntatore alle istruzioni in Unefunge-98, in stampa Tere maailm!.
5. La fissione non inizia affatto nell'angolo in alto a sinistra. R"Hej Verden!";viene eseguito. (Un altro puntatore di istruzioni parte da Din __END__, ma non fa nulla per poi morire fino a ;in true;.)

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

GolfScript vede `, quindi true(NOP), quindi un commento; quindi __END__(NOP); quindi "Hola Mundo!" puts(questo viene eseguito); poi case(NOP), quindi `(si arresta in modo anomalo su stack vuoto).

Le shell vedono un commento, quindi un'invocazione a true(NOP), quindi invocazioni a comandi sconosciuti __END__e "Hola Mundo!"(quale errore a STDERR ma l'esecuzione continua), quindi l' caseistruzione che si distingue in base alla prima lettera del nome del processo corrente.

Cardinal è un altro esolang 2D che inizia in corrispondenza del %, inviando 4 IP in alto, in basso, a sinistra e a destra. Sono tutti uccisi dai xcomandi circostanti , ma uno stampa "Olá Mundo!"prima di morire.

Il codice brainfuck è primo, con il prefisso ++per contrastare i trattini ps -p$$ -oargs=.

Lo spazio bianco nel mio codice viene eseguito come programma Spazio bianco

 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

quale stampa Helo Byd!

EDIT : Ho dimenticato che l'aggiunta di UDLRcaratteri interrompe il programma Fission, quindi ho modificato le stringhe per evitarle.

4 lingue, 75 byte

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

Python -Hai dunia!

Perl -Helo Byd!

Rubino -Hola món!

Pagliaio -Hej Verden!

7 lingue, 221 byte

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

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

Poiché questo programma contiene alcuni personaggi cattivi, ecco 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!".

• Stampe Unefunge-98 Përshendetje Botë!- Provalo online!
• Stampe Befunge-98 Hallo Wereld!- Provalo online!
• Stampe Trefunge-98 ሰላም ልዑል!- Provalo online!
• In realtà stampa Hello Wêreld!- Provalo online!
• Stampe Bash Kaixo Mundua!- Provalo online!
• Stampe PHP مرحبا بالعالم!- Provalo online!
• Stampe Retina Բարեւ աշխարհ!- Provalo online!

5 lingue, 168 byte

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

Penso che le lingue bidimensionali siano interessanti.

> <> stampe Tere maailm!
Befunge-98 stampe Hej Verden!
Cera d'api stampe Sawubona Mhlaba!
cardinali Stampe di Helo Byd!
fissioneHello World!

Provalo online! (Cardinale)

2 lingue, 16 caratteri, 24 byte

Beh, almeno questo è più corto di entrambe le stringhe.

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

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

Aiuto, WarDoq! -Hello World!

_{Aiuto, WarDoq! può aggiungere due numeri e testare i numeri primi, quindi è considerato un linguaggio di programmazione valido per questo meta post .}

3 lingue, 67 62 byte

Per qualificarsi per questa taglia (100 rep).

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

Aggiungi ++: provalo online!

Foo: provalo online!

Somme: provalo online!

Spiegazione

Aggiungere ++

Aggiungi ++ vede:

x:Helo Byd!
O

"Output x's string"

y:"Hai dunia!"

"Imposta y su una stringa diversa"

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

"idk qualcosa di strano, sbaglio"

foo

Foo vede:

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

"Oo, citazioni, le farò uscire."

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

"Uh ... qualcosa su una modalità? Idk, sbaglio."

Somme

Somme vede, beh, questo:

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

Ogni colonna viene convertita in punti di codice, quindi ne viene sottratta 32, quindi ciascuna è presa modulo 95. Questo corrisponde a questi caratteri, che stampano "Hei Verden!"

4 lingue, 138 byte

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

Provalo online!

Py1, Py2, Py3, Proton; grazie a Mr. Xcoder; tradotto dalla risposta di Zacharý

4 lingue, 115 byte

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

Quattro lingue, un enorme 650 byte

//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!" Provalo!

SILOS regala "Hola Mundo" Provalo!

Brainfuck dà "Ciao mondo!" Provalo!

(Il codice alphuck è modificato dalla pagina Esolangs su Alphuck )

Alphuck dà "Hello World!" Provalo!

La riga che inizia \ u000A è il codice Java. Il codice sulla riga uno è il codice Alphuck, che ignorerà il resto del codice (purché "p" e "s" siano bilanciati. La riga pertinente per SIL / SILOS è "stampa Hola Mundo" e il codice brainfuck è alla fine e ignorerà il resto del codice.

5 lingue, 213 byte

Ho deciso di provare a scrivere una piccola risposta da solo.

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

Le lingue:

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 ++ vedono il codice come:

#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;è (in effetti) uguale a int i=0;in C, ma uguale a double i=0.5;in C ++.

Provalo online! (come C)

Provalo online! (come C ++)

Python 3 vede il codice come:

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

Provalo online!

Il linguaggio di scripting OFP vede:

; (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 fissione vede:

R "Pozdrav svijete!";

Provalo online!

3 lingue, 184 181 byte

Funziona solo una volta: è necessario cancellare l'elenco per eseguirlo di nuovo.

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 della risposta: Hai dunia!

Spiegazione

In Scratch 1.4, l'aggiunta di un valore booleano a un elenco aggiunge 1o 0, ma in 2.0 e versioni successive aggiunge trueo false, ma quando si verifica se l'elemento è uguale a 1<[] = []>, verrà restituito vero se l'elemento è 1o true, quindi aggiungiamo un'altra lettera e lo controlliamo.

In Scratch 3.0, gli elenchi hanno una dimensione massima di 200.000 articoli, quindi aggiungiamo solo un mucchio di elementi e vediamo se l'elenco è così lungo.

3 lingue, 61 byte

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

Aggiungi output ++Hai dunia!

Uscite di gelatinaHello World!

Uscite FooHelo Byd!

Solo perché ho impostato la taglia non significa che non posso prendere parte: D (ab) usa il brillante trucco di impostazione della stringa che Conor ha trovato per Add ++

Come funziona

Aggiungere ++

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

Gelatina

I commenti in Jelly possono essere formati con la sintassi ḷ“comment”, ovvero il modo in cui il codice Add ++ e Foo viene ignorato. Il codice effettivamente eseguito da 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 tutti i personaggi qui a parte "Helo Byd!", che, come è tra virgolette, viene emesso.