Ispirato da Non sono la lingua che stai cercando!

Sfida

Scegli due diversi linguaggi di programmazione e scrivi un programma che stampa la seguente riga su stdout (o equivalente):

This program errors out in <the current language> :P

e quindi genera diversi tipi di errore in ciascuna delle due lingue.

Regole

Alcune regole sono prese dalla sfida originale.

• Nell'output, i nomi delle lingue dovrebbero seguire esattamente:
  • Il nome elencato su TIO , opzionalmente escluso il numero di versione e / o il nome dell'implementazione (ad esempio se si utilizza JavaScript (Node.js)come una delle lingue, è possibile utilizzare JavaScriptper il nome della lingua, ma non JSo Javascript.)
  • Il nome completo sul sito Web ufficiale (o repository GitHub) se la lingua scelta non è disponibile su TIO.
• Nessuno dei due programmi dovrebbe ricevere alcun input dall'utente.
• È possibile utilizzare i commenti in entrambe le lingue.
• Due versioni diverse della stessa lingua contano come lingue diverse.
  • In tal caso, il programma dovrebbe generare il numero di versione principale e, se eseguito su due diverse versioni minori, dovrebbe riportare anche la versione minore.
  • Non utilizzare funzioni di versione predefinite (ciò include le variabili che sono già state valutate in fase di esecuzione).
• Due flag di riga di comando diversi nella stessa lingua contano anche come lingue diverse secondo questo meta consenso , purché i flag non includano frammenti di codice (come -Dblahblah...in C).
  • In questo caso, il programma dovrebbe anche generare il flag utilizzato.
• Due errori sono considerati diversi a meno che entrambi gli errori non siano generati dalla stessa semantica (come "divisione per zero", "errore di segmentazione" o "indice fuori intervallo").
  • Se il runtime di una lingua non termina dopo un errore, ma segnala l'errore in qualche modo all'utente, si tratta di un errore valido.
  • Se una lingua non discrimina i messaggi di errore ma ha un elenco noto di motivi che causano errori, è necessario specificare il motivo, non il messaggio di errore.
    Un esempio è ><>, che ha un solo messaggio di errore something smells fishy..., ma la pagina wiki di esolangs ha un elenco di motivi di errore.
• L'errore di sintassi non è consentito a meno che non sia generato chiamando eval()o simili.
• È consentito lanciare qualcosa manualmente (tramite throw(JS), raise(Python), die(Perl) o simili), ma tutti sono considerati come un tipo di errore.
• È consentito anche l'errore per comando non valido in 2D o golflang (e trattato come un tipo di errore).

Esempi

Python e Ruby

• Python: This program errors out in Python :Psu stdout, quindi identificatore non definito
• Ruby: This program errors out in Ruby :Psu stdout, quindi indicizza fuori dai limiti

C89 e C99

• C89: This program errors out in C 89 :Pa stdout, quindi divisione per zero
• C99: This program errors out in C 99 :Psu stdout, quindi errore di segmentazione

Si noti che il numero di versione deve essere sempre separato dal nome della lingua da uno spazio.

Python 2.7.9 e Python 2.7.10

• Python 2.7.9: This program errors out in Python 2.7.9 :Psu stdout, quindi errore di sintassi su eval
• Python 2.7.10: This program errors out in Python 2.7.10 :Psu stdout, quindi errore chiave su dict

Perl e Perl -n

• Perl: This program errors out in Perl :Psu stdout, quindi formato orario non valido
• Perl -n: This program errors out in Perl -n :Psu stdout, quindi prova ad aprire un file che non esiste

Condizioni vincenti

Questo è code-golf , quindi vince il codice più breve in byte. Ma sei sempre incoraggiato a pubblicare una risposta divertente o interessante anche se non molto breve.

Python 2 / Python 3 , 60 byte

print("This program errors out in Python %d :P"%(3/2*2))*1;a

• Python 2 ottenuto NameError: name 'a' is not defined
• Python 3 ottenuto unsupported operand type(s) for *: 'NoneType' and 'int'

Python 2:

• /è divisione intera, 3/2 ottenuto 1; int (3/2 * 2) è 2.
• print è un'istruzione, quindi la prima istruzione legge come print((...)*1), qui *1significa ripetere una volta la stringa.
• la seconda istruzione fa riferimento a una variabile inesistente, che ha causato l'errore.
• Provalo online!

Python 3:

• '/' è divisione numerica mobile, 3/2 ottenuto 1.5; int (3/2 * 2) è 3.
• print è una funzione, quindi la prima istruzione viene letta come (print(...))*1.
• la funzione printritorna None; La moltiplicazione non funziona None x int, quindi riporta "operando non supportato".
• Provalo online!

C e C ++, 114 101 byte

-13 byte grazie a l4m2 !

#include<stdio.h>
main(){auto d=.5;printf("This program errors out in C%s :P",d?"++":"");2[&d]+=1/d;}

Errore di segmentazione in C ++, eccezione in virgola mobile in C.

autoè impostato di default su intin C così (int).5diventa 0, quindi cercare di dividerlo è sostanzialmente divisione per zero.

In C ++ 1/dè 2, aggiungendolo all'indirizzo di de cercando di cambiare quell'indirizzo 'il valore genera un segfault.

Provalo in C ++!
Provalo in C!

JavaScript + HTML / HTML + JavaScript, 160 byte

<!--
document.write`This program errors out in JavaScript + HTML :P`()
--><script>document.write`This program errors out in HTML + JavaScript :P`+X</script>

<!--
document.write`This program errors out in JavaScript + HTML :P`()
--><script>document.write`This program errors out in HTML + JavaScript :P`+X</script>

Non sono sicuro se questo conta due lingue, ma è divertente.

Java 8 e C99, 172 byte

//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

Basato sulla mia risposta per la sfida "abc" e "cba" .

Provalo in Java 8 - con conseguente ArrayIndexOutOfBoundsException: 1 .
Provalo in C - con conseguente eccezione in virgola mobile: la divisione per zero non è definita .

Spiegazione:

//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

Come puoi vedere nel codice evidenziato in Java sopra, la prima riga è un commento a causa //e il codice C è un commento a causa /* ... */, risultante in:

interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]="";}}

Quindi stampa su STDOUT e quindi tenta di accedere al secondo argomento del programma (quando non ne viene fornito nessuno), quindi produce ArrayIndexOutOfBoundsException .

//\
interface a{static void main(String[]a){System.out.print("This program errors out in Java 8 :P");a[1]=""/*
main(n){{n=puts("This program errors out in C99 :P")/0/**/;}}

Non sono sicuro di come abilitare correttamente l'evidenziazione a C, perché lang-ccomporta lo stesso evidenziamento di Java .. Ma //\commenterà la riga successiva, che è il codice Java, risultante in:

main(n){{n=puts("This program errors out in C99 :P")/0;}}

Quindi preme STDOUT e quindi dà una divisione per zero errori.

Java 8 & Whitespace , 439 431 428 408 byte

                         






























 interface a{static void    main(String[]a){System.out.print("This program errors out"+
" in Java 8 :P");a[0]="";}}

Provalo in Java 8 - con conseguente ArrayIndexOutOfBoundsException: 0 .
Provalo in Whitespace - con conseguente errore dell'utente (Impossibile eseguire Infix Plus) .

Spiegazione:

Java 8:

interface a{static void main(String[]a){System.out.print("This program errors out"+
" in Java 8 :P");a[0]="";}}

Quindi stampa su STDOUT e quindi tenta di accedere al primo argomento del programma (quando non ne viene fornito nessuno), quindi produce ArrayIndexOutOfBoundsException .

Spazio bianco:

[S S T  T   T   T   T   T   N
_Push_-31_P][S S T  T   T   S T S T N
_Push_-53_:][S S T  T   S S T   T   T   T   N
_Push_-79_space][S S T  T   S T S N
_Push_-10_e][S S T  T   T   S S N
_Push_-12_c][S S T  T   T   T   S N
_Push_-14_a][S S S T    N
_Push_1_p][S S S T  S S N
_Push_4_s][S S T    T   S T S N
_Push_-10_e][S S S T    S T N
_Push_5_t][S S T    T   T   S N
_Push_-6_i][S S T   T   T   T   N
_Push_-7_h][S S T   T   T   S S S N
_Push_-24_W][S T    S S T   S T S N
_Copy_0-based_10th_(-79_space)][S S T   T   N
_Push_-1_n][S S T   T   T   S N
_Push_-6_i][S T S S T   S N
_Copy_0-based_2nd_(-79_space)][S S S T  S T N
_Push_5_t][S S S T  T   S N
_Push_6_u][S S S N
_Push_0_o][S T  S S T   T   N
_Copy_0-based_3rd_(-79_space)][S S S T  S S N
_Push_4_s][S S S T  T   N
_Push_3_r][S S S N
_Push_0_o][S S S T  T   N
_Push_3_r][S N
S _Duplicate_top_(3_r)][S S T   T   S T S N
_Push_-10_e][S T    S S T   T   S N
_Copy_0-based_6th_(-79_space)][S S T    T   S N
_Push_-2_m][S S T   T   T   T   S N
_Push_-14_a][S S S T    T   N
_Push_3_r][S S T    T   S S S N
_Push_-8_g][S S S S (_Note_the_additional_S_here)N
_Push_0_o][S S S T  T   N
_Push_3_r][S S S T  N
_Push_1_p][S T  S S T   T   T   N
_Copy_0-based_7th_(-79_space)][S S S T  S S N
_Push_4_s][S S T    T   T   S N
_Push_-6_i][S S T   T   T   T   N
_Push_-7_h][S S T   T   T   S T T   N
_Push_-27_T][N
S S N
_Create_Label_LOOP][S S S T T   S T T   T   T   N
_Push_111][T    S S S _Add][T   N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Lettere S(spazio), T(scheda) e N(nuova riga) aggiunti solo come evidenziazione.
[..._some_action]aggiunto solo come spiegazione.

Prova questa versione evidenziata.

Whitespace è un linguaggio basato su stack che ignora tutto tranne spazi, tabulazioni e nuove righe. Ecco lo stesso programma in pseudo-codice:

Push all unicode values of "P: ecapsetihW tuo srorre margorp sihT", minus 111
Start LOOP
  Push 111
  Add the top two stack values together
  Print as character
  Go to the next iteration of the LOOP

Si interromperà non appena avrà finito di stampare tutti i valori e lo stack è vuoto quando si tenta di eseguire Add ( TSSS), che richiede due elementi nello stack.

Ho generato la costante 111con questo programma Java , che ho usato anche per le precedenti sfide relative ad ASCII che ho fatto in Whitespace. Inoltre, ho usato alcune copie degli spazi per salvare byte.

Una cosa importante da notare è il trucco che ho usato per posizionare il programma Java nella risposta agli spazi bianchi. Vorrei iniziare spiegando come viene spinto un numero in Whitespace:

Sall'inizio: Abilita manipolazione stack;
S: Push ciò che segue come Numero;
Soppure T: rispettivamente positivo o negativo;
Alcuni Se / o T, seguiti da un N: Numero come binario, dove T=1e S=0.

Ecco alcuni esempi:

• Premendo il valore 1 sarà SSSTN;
• Spingendo il valore -1 sarà SSTTN;
• Premendo il valore 111 sarà SSSTTSTTTTN.
• Spingendo il valore 0 può essere SSSSN, SSTSN, SSSN, SSTN, SSSSSSSSSSSSN, ecc (Quando si utilizza SSSN(o SSTN), non abbiamo per specificare la parte binaria, perché è implicito 0 dopo che noi abbiamo affermato il suo segno.)

Quindi SSSNè sufficiente per spingere il valore 0(usato per la lettera oin questo caso). Ma, per posizionare il programma Java in questo programma Whitespace golfizzato, avevo bisogno di uno spazio aggiuntivo, quindi i primi due osono spinti SSSN, ma il terzo è spinto con SSSSN, quindi abbiamo abbastanza spazi per la frase del programma Java.

CBM BASIC e codice macchina 6502 (C64), 142 144 byte

Ho dovuto aggiungere 2 byte dopo aver realizzato un errore di sintassi non era permesso ....

Hexdump del .prgfile:

01 08 50 08 00 00 8F 5A 49 52 49 41 A9 17 8D 18 D0 A2 30 BD 30 08 20 D2 FF E8
E0 4B D0 F5 A2 30 BD 05 08 20 D2 FF E8 E0 44 D0 F5 A9 0D 20 D2 FF A2 1A 4C 37
A4 22 36 35 30 32 20 4D 41 43 48 49 4E 45 20 43 4F 44 45 20 3A D0 22 20 20 20
20 20 00 8D 08 01 00 97 35 33 32 37 32 2C 32 33 3A 99 22 D4 48 49 53 20 50 52
4F 47 52 41 4D 20 45 52 52 4F 52 53 20 4F 55 54 20 49 4E 20 C3 C2 CD 2D C2 C1
D3 C9 C3 20 3A D0 22 2C 58 AD 50 00 00 00

La vista BASIC CBM , come elencato nell'editor del C64:

0 remziriastepgosubinput#new0exp0 dim.clrsavekinput#stepnew0exp<white> dim.clrsavedinput#stepstep
 dim.newl7to"6502 machine code :P"
1 poke53272,23:print"This program errors out in CBM-BASIC :P",x/p

Attenzione : è impossibile inserire correttamente questo programma nell'editor BASIC. Non provare nemmeno a modificare questo programma nell'editor BASIC, si bloccherà. Tuttavia, è un programma BASIC eseguibile;)

La vista codice macchina 6502 :

         01 08                          ; load address

.C:0801  50 08       BVC $080B          ; jump to real start of mc

         ; line number (00 00), REM (8F) and "ziria"
.C:0803  00 00 8F 5A 49 52 49 41

.C:080b  A9 17       LDA #$17
.C:080d  8D 18 D0    STA $D018          ; set upper/lower font
.C:0810  A2 30       LDX #$30
.C:0812  BD 30 08    LDA $0830,X
.C:0815  20 D2 FF    JSR $FFD2          ; print "This program errors ..."
.C:0818  E8          INX
.C:0819  E0 4B       CPX #$4B
.C:081b  D0 F5       BNE $0812
.C:081d  A2 30       LDX #$30
.C:081f  BD 05 08    LDA $0805,X
.C:0822  20 D2 FF    JSR $FFD2          ; print "6502 machine code :P"
.C:0825  E8          INX
.C:0826  E0 44       CPX #$44
.C:0828  D0 F5       BNE $081F
.C:082a  A9 0D       LDA #$0D
.C:082c  20 D2 FF    JSR $FFD2          ; print a newline
.C:082f  A2 1A       LDX #$1A           ; error code for "can't continue"
.C:0831  4C 37 A4    JMP $A437          ; jump to error handling routine

.C:0834  22 ; '"'

         ; "6502 machine code :P"
.C:0835  36 35 30 32 20 4D 41 43 48 49 4E 45 20 43 4F 44 45 20 3A D0

         ; '"', some spaces, and next BASIC line
.C:0849  22 20 20 20 20 20 00 8D 08 01 00 97 35 33 32 37 32 2C 32 33 3A 99 22

         ; "This program errors out in CBM-BASIC :P"
.C:0860  D4 48 49 53 20 50 52 4F 47 52 41 4D 20 45 52 52 4F 52 53 20 4F 55 54
.C:0877  20 49 4E 20 C3 C2 CD 2D C2 C1 D3 C9 C3 20 3A D0

.C:0887  22 2C 58 AD 50 00 00 00

Demo online , digitarerunper eseguire come BASIC,sys 2049per eseguire come codice macchina,listper mostrarlo interpretato come codice BASIC.

L'esecuzione come BASIC produce un division by zero error in 1, in esecuzione come codice macchina acan't continue error

Spiegazione:

I primi due byte di un .prgfile sono l'indirizzo di caricamento in little endian, qui è $0801(decimale 2049), che è l'indirizzo iniziale per i programmi BASIC sul C64. runavvia questo programma nell'interprete BASIC, mentre sys 2049è il comando per eseguire un programma di codice macchina all'indirizzo 2049.

Come puoi vedere, la prima riga nella vista BASIC è un commento ( rem) contenente "garbage" e parte della stringa di output richiesta. Questo è il programma del codice macchina e alcuni byte di riempimento. Qui vedi alcuni comandi BASIC "casuali" perché i programmi CBM-BASIC contengono i comandi "tokenizzati" come valori a byte singolo e alcuni di questi valori sono gli stessi dei codici operativi utilizzati nel codice macchina. Il codice macchina riutilizza la stringa presente nella seconda riga di codice per il suo output.

I primi due byte di una riga di un programma di base sono un puntatore alla riga successiva, qui $0850. Questo è scelto con cura perché 50 08è anche un'istruzione di ramo 6502 che salta sugli 8 byte successivi quando il flag di overflow non è impostato - questo viene usato per saltare da qualche parte nel mezzo di questa riga "comment" quando eseguito come codice macchina. Il 50è il codice operativo utilizzato qui, quindi la seconda linea deve iniziare a 0850per il trucco al lavoro. Ecco perché viene visualizzata una sequenza di 5 20byte (caratteri di spazio) da riempire. Il codice macchina passa attivamente alla routine di gestione degli errori ROM per dare un errore "Impossibile continuare".

Il codice BASIC è piuttosto semplice; come secondo argomento da "stampare", due variabili non inizializzate (che hanno un valore 0in CBM BASIC) sono divise, innescando l'errore "divisione per zero".

> <> e Foo , 42 byte

#o<"This code errors in "p"Foo"'><>'" :P"/

Provalo in> <>!

Provalo in Foo!

Foo stampa tutto ", come è ben documentato, e cerca di dividere per zero alla fine. Ignora il '><>'.

><>spinge il "Foo" nello stack, ma lo pop immediatamente usando p. Dopo aver stampato tutto nello stack con #o<esso esce quando lo stack è vuoto con l'unico messaggio di errore che conosce,something smells fishy...

C e Python, 126 116 byte

-10 byte grazie a @Bubbler!

#1/*
-print("This program errors out in Python :P")
'''*/
main(c){c=puts("This program errors out in C :P")/0;}//'''

In Python print () è un None, quindi cercare di ottenere il suo negativo non ha senso, quindi Python genera un errore.

In C printf () restituisce un int, quindi dividendolo per zero si ottiene un'eccezione in virgola mobile.

Provalo in C!
Provalo in Python!

Attache + Wolfram Language (Mathematica) , 82 byte

s:="Attache"
s=" Mathematica "
Throw[Print["This program errors out in",s,":P"]-0]

Prova Attache online! Prova Mathematica online!

Ciò ruota attorno al significato dell'operatore =nelle due lingue. In Attache, confronta per uguaglianza, ma in Mathematica, esegue assegnazioni variabili. :=fa assegnazione variabile in entrambe le lingue.

Ora, in Attache, Printrestituisce una matrice di stringhe stampate e la sottrazione non è possibile con stringhe e numeri interi (ovvero, 0). Quindi, viene generato un errore di tipo. In Mathematica, i Printritorni Null, e Mathematica sta semplicemente sottraendo 0da quello. Ma lanciamo manualmente quel null con Throw, dando un nocatcherrore.

Python (2) e QB64 , 82 byte

1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

Per testare la versione di Python, puoi provarla online! Per testare la versione QB64, dovrai scaricare QB64.

Cosa vede Python

1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

La prima riga è solo l'espressione nuda 1(no-op) seguita da un commento.

La seconda riga imposta ssulla stringa "QB64", ma la terza riga la modifica immediatamente in "Python". La quarta riga stampa il messaggio di conseguenza.

La quinta riga è un'altra espressione nuda, ma solleva un a NameErrorcausa del nome indefinito CLS.

Cosa vede QB64

1#DEFSTR S
s="QB64"
'';s="Python"
print"This program errors out in "+s+" :P"
CLS-1

La prima riga, numerata 1#, definisce ogni variabile il cui nome inizia con S(senza distinzione tra maiuscole e minuscole) come variabile stringa. Questo significa che non dobbiamo usare s$, il che sarebbe un errore di sintassi in Python.

La seconda riga imposta ssulla stringa "QB64". 'inizia un commento in QB64, quindi la terza riga non fa nulla. La quarta riga stampa il messaggio di conseguenza.

La quinta riga tenta di CLS(cancellare lo schermo) con un argomento di -1. Ma dal momento che CLSaccetta solo argomenti di 0, 1o 2, questo produce l'errore Illegal function call. L'errore crea una finestra di dialogo che chiede all'utente se desidera continuare l'esecuzione o interrompere. Tecnicamente, questo significa che l'errore non è fatale (in questo caso, è possibile selezionare "continua esecuzione" e il programma termina semplicemente senza ulteriori problemi); ma l'OP ha esplicitamente consentito lingue che possono continuare dopo un errore, quindi il comportamento di QB64 dovrebbe andare bene.

Perl 5 e JavaScript (Node.js) , 96 byte

eval("printf=console.log");printf("This program errors out in %s :P",("Perl","JavaScript"));$//0

Questo fa uso del fatto che (...)è un elenco in Perl che printfutilizzerà l'elemento più a sinistra di e del fatto che è l'operatore virgola in JavaScript, che restituirà l'argomento più a destra.

Provoca una divisione per zero errori in Perl e un ReferenceError perché $non è definito in JavaScript.

Prova il Perl online!

Prova JavaScript online!

Octave e MATLAB, 67 byte

v=ver;disp(['This program errors out in ' v(1).Name ' :P']);v(--pi)

Provalo online!

Note: il codice presuppone che MATLAB sia installato senza toolbox (o che i nomi di qualsiasi toolbox installato non inizino con le lettere dalla A alla M).

Come funziona:

Il codice ottiene i dati della versione per l'interprete e le cassette degli strumenti utilizzando ver. Running v(1).Nameestrae il nome del primo prodotto, questo restituirà uno Octaveo MATLABassumendo che la nota sopra sia vera.

Il programma visualizzerà quindi la stringa richiesta, completa con Octaveo MATLABcome richiesto.

Finalmente lo facciamo v(--pi).

In Octave, --è l'operatore pre-decremento. Come tale, tenta di pre-decrementare, ma fallisce perché la variabile pinon esiste ( piè in realtà una funzione, non una variabile).

This program errors out in Octave :P
error: in x-- or --x, x must be defined first

In MATLAB, l'operatore pre-decremento non esiste. Come tale l'affermazione viene interpretata come v(-(-pi))uguale a giusto v(pi). Tuttavia pinon è un numero intero, quindi non può essere utilizzato per indicizzare vnell'array, dando un errore.

This program errors out in MATLAB :P
Subscript indices must either be real positive integers or logicals.

C ++ 14 (gcc) / C ++ 17 (gcc) , 107 105 byte

#include<cstdio>
int*p,c=*"??/0"/20;int
main(){*p=printf("This program errors out in C++ 1%d :P",4+c)/c;}

Provalo online! (C ++ 14)

Provalo online! (C ++ 17)

Suppone che <cstdio>dichiari printfnello spazio dei nomi globale (oltre a std) e che il set di caratteri di esecuzione di base utilizzi valori ASCII, che sono entrambi veri usando g ++ su Linux.

Il trucco di base qui è che C ++ 17 ha eliminato le trigrafie dalla lingua.

In C ++ 14, "??/0"contiene una trigrafia ed è equivalente a "\0". Quindi *"??/0"è zero ed cè impostato su zero. Il numero 4 viene passato come argomento a printf, quindi la divisione ccausa un comportamento indefinito. Su Linux, questo accade prima che *pvenga visualizzato, e il programma ottiene un SIGFPE.

In C ++ 17, "??/0"è esattamente la stringa di lunghezza 4 che sembra essere. Così *"??/0"è '?'o 63, ed cè impostato su 3. Il numero 7 viene passato come argomento a printf, e questa volta la divisione per cè valida. Poiché pè un membro dello spazio dei nomi, viene inizializzato con zero all'inizio del programma e ha un valore di puntatore nullo, quindi il *pcomportamento non è definito. Su Linux, poiché il programma tenta di modificare la memoria all'indirizzo zero, il programma ottiene a SIGSEGV.

Perl 5 e Perl 6 , 55 byte

say('This program errors out in Perl ',5-~-1,' :P').a/0

Prova Perl 5 online! (Divisione illegale per zero)

Prova Perl 6 online! (Nessun metodo simile)

Il prefisso ~è una stringa in Perl 6 ed essenzialmente un no-op nel programma sopra. In Perl 5, non è bit a bit, convertendo -1 in 0.

. è la sintassi della chiamata del metodo in Perl 6 e la concatenazione in Perl 5.

C (gcc) / Stax , 109 byte

AA=~1;
	char* s;main(){*(int*)(printf("%s C :P",s))=0;}char* s=
"This program errors out in";;;/*dp`UGYC\`Q*/

Provalo online! (C (gcc))

Provalo online! (Stax) o Esegui ed esegui il debug! (Stax)

Segfault in C. Operazione non valida in Stax. Adoro come tutto ciò che non è un commento viene effettivamente utilizzato in Stax.

C

Ecco come lo vede C. La prima riga è no-op. La seconda riga stampa il messaggio con printfe quindi segfaults a causa di =0.

AA=~1;
	char* s;main(){*(int*)(printf("%s C :P\n",s))=0;}char* s=
"This program errors out in";;;/*dp`UGYC\`Q*/

Stax

Il programma Stax termina ogni volta che tenta di apparire o sbirciare dallo stack vuoto. Questo rende un po 'complicato e dobbiamo preparare una pila che non è vuota. AA=~1;fa questo pur rimanendo una dichiarazione valida in C.

AA=~1;
AA=       10=10, returns a 1
   ~      Put it on the input stack
    1     Pushes a 1 to main stack (*)
     ;    Peek from the input stack (**)

Ciò che è veramente utile è il ~, prepara uno stack di input non vuoto in modo che ;possa essere eseguito senza uscire dal programma. Tuttavia, i due 1secondi nello stack principale vengono utilizzati anche in seguito.

La seconda riga inizia con una scheda e inizia un commento di riga in Stax.

"...";;;/*dp`UGYC\`Q*/
"..."                     "This program errors out in"
     ;;;                  Peek the stack three times so that we have enough operands for the next two operations
        /                 Divide, this consumes one element of the main stack
         *                Multiply, this consumes another element
          d               Discard the result, now the TOS is the string
           p              Pop and print without newline
            `UGYC\`       Compressed string literal for " Stax :P"
                   Q      Print and keep the string as TOS
                    *     Duplicate string specific times
                          Since the element under the top of stack is `1` that was prepared in (**), this does nothing
                     /    Invalid operation error

L'operazione non valida sta tentando di eseguire /un'operazione per una stringa come TOS (2o operando) e il numero 1da (*) come 1o operando, che non è valido.

Se i due operandi vengono scambiati, sarebbe un'operazione valida in Stax.

Jelly e M , 39 byte

İ=`ị“¢³ƥ“Ȥ¹»;“ :P”“¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»;ȮṠṛƓ

Provalo in Jelly!

Provalo in M!

Entrambe le lingue si applicano İal contrario di ciò 0che risulta infper Jelly e zooper M. Non so perché zoorappresenti l'infinito in M. Chiedi a Dennis.

La differenza importante è che l'infinito di Jelly è uguale a se stesso mentre l'infinito di M non lo è. Così la monade "è uguale a se stessa" =`produce 1in Jelly e 0in M. Da qui:

İ=`ị“¢³ƥ“Ȥ¹»;“ :P”“¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»;ȮṠṛƓ
İ=`                                      0 in M, 1 in Jelly
    “¢³ƥ“Ȥ¹»                             Pair of compressed strings: [' M',' Jelly']
   ị                                     Index into this list with 0 or 1
            ;“ :P”                       Concatenate with the string ' :P'
                  “¢ḅñ⁵ẹḞŀẊịñṙȧṄɱ»       Compressed string: 'This program errors in'
                                  ;      Prepend this to ' Jelly/M :P'
                                   Ȯ     Print the string and return it
                                    Ṡ    Sign. M errors with a string as input and terminates
                                         Jelly returns a list of Nones
                                     ṛ   Right argument. This prevents the list of Nones from being printed
                                      Ɠ  Read a single line from input. Since input is not allowed, this produces an EOFError

L'errore di Jelly è EOFError: EOF when reading a line.

L'errore di M è TypeError: '>' not supported between instances of 'str' and 'int'.

Foo / CJam , 51 50 byte

"This program errors out in ""Foo"/'C'J'a'm" :P"Li

Questo esce con un errore di divisione per zero in Foo e un NumberFormatExceptionin CJam.

Per CJam:

• Una stringa letterale (tra virgolette) si inserisce nello stack. Gli articoli dalla pila vengono stampati automaticamente senza un separatore al termine del programma.
• /prova a dividere la stringa This program errors out in sulla sottostringa Foo. Poiché la stringa non contiene la sottostringa, ciò produce un array singleton contenente la stringa originale, che viene visualizzata esattamente allo stesso modo.
• 'xè un carattere letterale per x, che viene stampato allo stesso modo di una stringa di un carattere. In questo modo, possiamo spingere i dati per CJam che viene ignorato da Foo (non ho capito come fare un loop non eseguire in Foo).
• Litenta di eseguire il cast della stringa vuota su un numero intero, che non riesce. Viene stampato tutto dalla pila.

Per Foo:

• Una stringa letterale (tra virgolette) si stampa da sola.
• /tenta di dividere la cella corrente per l'elemento stack superiore (che è implicito 0). Per qualche motivo, gli errori di divisione per 0 non sono fatali in Foo, quindi questo stampa il messaggio

  Only Chuck Norris can divide by zero.

  a STDERR e continua.
• I caratteri non riconosciuti ( 'C'J'a'me Li) vengono ignorati.

Python e Lua , 111 110 102 98 95 95 85 byte

x="This program errors out in ",#[[
print(x[0]+"Python :P")
a#]]z=#print(x.."Lua :P")

Errori: Python 3:

Traceback (most recent call last):
  File ".code.tio", line 3, in <module>
    a#]]z=#print(x.."Lua :P")
NameError: name 'a' is not defined

Lua:

lua: .code.tio:3: attempt to get length of a nil value
stack traceback:
    .code.tio:3: in main chunk
    [C]: in ?

Chiaramente distinto.

Abusa di differenze multiple:

• <var>=<a>,<b>,... crea una tupla in Python, ma in Lua crea un elenco di argomenti, dal quale viene preso solo il primo membro.
• #inizia un commento in Python, ma è l'operatore lunghezza in Lua. Puntelli extra su Python per consentire alle tuple di finire in una virgola.
• [[...]]è la sintassi della stringa multilinea di Lua, il che significa che non vede nemmeno la funzione di stampa di Python; questo è necessario a causa dell'utilizzo di Lua ..per la concatenazione di stringhe e non +.
• Errori Python dopo aver visto a, una variabile non definita; Lua dopo z=#print(x.."Lua :P"). L'uso solo #print(x.."Lua :P")per Lua non funziona, in quanto genera un errore prima ancora che il codice venga eseguito.

modifiche:

• Non è necessario utilizzare "".joinin Python, -1 byte
• Crea xuna stringa in entrambe le lingue e posizionala Pythonin una stringa letterale nella funzione di stampa, -8 byte
• L'utilizzo #[[]]è più breve di #""e --[[]], -4 byte
• Non è necessario utilizzare #1come chiave di tabella, -3 byte
• Jo King ha fatto questo , -9 byte
• Prendendo la lunghezza del valore di ritorno delle print(x.."Lua :P")opere, apparentemente; -1 byte

Java e C # 242 235

/**\u002f/*/using System;/**/class G{public static void/**\u002fmain/*/Main/**/(String[]a){String s="This program errors out in ";/**\u002fSystem.out.print(s+"Java :P");/*/Console.Write(s+"C# :P")/**/;s=/**\u002f(1/0)+""/*/a[-1]/**/;}}

Abusare di diverse gestioni di escape tra java e C # (le escape unicode vengono analizzate prima dell'analisi del codice in java e non in c #) come una sorta di preprocessore, questo è il lavoro della \u0027magia, resto sono alcuni "toggle-commenti"

Modifica: golfato di 8 byte grazie a un puntatore di @KevinCruijssen

Modifica: Rule derp risolto

Tasto AutoHot / C #, 155 133 128 122 byte

L'evidenziazione della sintassi lo spiega meglio di quanto potrei:

C # RuntimeBinderException: "Impossibile richiamare un tipo non delegato"

;dynamic
i="This program errors out in " ;Console.Write(i+"c# :P");i();/*
i:=SubStr(i,2,27)
send %i%AutoHotkey :P
Throw */

Errore tasto automatico : è stata generata un'eccezione.

;dynamic
i="This program errors out in " ;Console.Write(i+"c# :P");i();/*
i:=SubStr(i,2,27)
send %i%AutoHotkey :P
Throw */

modifiche:

1. rimosso una var
2. -5 byte grazie al latte

PHP 7+ / JavaScript, 90 89 byte

Questo utilizza 2 lingue con sintassi molto simili, permettendo di scrivere questo codice su entrambe le lingue.

La separazione del linguaggio è fatta da una proprietà non presente in JavaScript: PHP considera [](array vuoto) un valore falso mentre è vero in JavaScript (perché è un oggetto e gli oggetti sono sempre veri, anche new Boolean(false)).

$X='This program errors out in %s :P';([]?console.log($X,'JavaScript'):printf($X,PHP))();

Esecuzione:

Si concentrerà sul seguente pezzo di codice: ([]?console.log($X,'JavaScript'):printf($X,PHP))();.

L'attribuzione della stringa funziona allo stesso modo in entrambe le lingue.

Questo codice utilizza l '"operatore ternario" ( Javascript , PHP ), che funziona principalmente allo stesso modo in entrambe le lingue.

Javascript

Javascript eseguirà il console.log($X,'JavaScript')pezzo, che ritorna undefined.

Successivamente, quando si tenta di eseguire (...)(), si ottiene un Uncaught TypeError: (intermediate value)(intermediate value)(intermediate value) is not a function(in Google Chrome).

PHP

PHP eseguirà il printf($X,PHP)pezzo.

In PHP, la printffunzione restituisce la lunghezza dell'output .

PHP ha una funzionalità interessante: può eseguire funzioni il cui nome è memorizzato in una variabile (o, dal momento che PHP7, come risultato di un'espressione), che impedisce un errore di sintassi.

PHP tenterà quindi di eseguire la funzione il cui nome è il risultato dell'espressione []? ... :printf($X,PHP)(che è il numero 33).
Ma quella funzionalità interessante ha un avvertimento: accetta solo stringhe (duh!).

Questo provoca un Fatal error: Function name must be a string, perché 33è un int.

Grazie a Shieru Asakoto per avermi salvato 1 byte!

Perl 5 e C, 95 byte

//;$_='
main(){puts(puts("This program errors out in C :P"));}//';/T.*n /;print$&,"perl :P";die

//; è fondamentalmente un NOP in perl, ed è un commento in C.

Quindi il programma C è efficacemente:

main(){puts(puts("This program errors out in C :P"));}

Che stampa la stringa richiesta, quindi tenta di eseguire puts(32). Questo è un comportamento tecnicamente indefinito in C, ma provoca un errore di segmentazione su TIO e su tutti i sistemi a cui ho accesso.

Il programma perl considera l'intero programma C come una stringa, usa la regex /T.*n /per abbinare This program errors out ine quindi stampa quello e perl :P. diecausa l'arresto anomalo del programma con l'errore Died at script_name line 2.

Se non ti piace che sia un errore, 1/0è della stessa lunghezza e si blocca con un Illegal division by zeroerrore. Mi piace di diepiù;)

Provalo online! (C)

Provalo online! (Perl)

VBScript, JScript, 72 byte

x="VB"
'';x='J'
WScript.echo("This program errors out in "+x+"Script")
y

VBScript stamperà "Errore di runtime di Microsoft VBScript: Tipo non corrispondente: 'y'"
JScript stamperà "Errore di runtime di Microsoft JScript: 'y' non definito"

JavaScript e Python 3, 105 91 byte

Errori di NameError: name 'console' is not definedin Python 3

a="This program errors out in %s :P"
1//2;print(a%"Python 3")
console.log(a,"JavaScript")()

Provalo online!

... e da TypeError: console.log(...) is not a functionin JavaScript.

a="This program errors out in %s :P"
1//2;print(a%"Python 3")
console.log(a,"JavaScript")()

Provalo online!

Java (JDK) / JavaScript (Node.js), 154 byte

class P{P(){var s="This program errors out in ";try{System.out.printf("%sJava :P",s);}finally{if(1!='1'){var a=0/0;}throw new Error(s+"JavaScript :P");}}}

Provalo online! (Giava)

Provalo online! (JavaScript)

Uscita in Java:

This program errors out in Java :P
Exception in thread "main" java.lang.ArithmeticException: / by zero
    at P.(Main.java:1)

Output in JavaScript (su stderr):

Error: This program errors out in JavaScript :P
    at P (/home/runner/.code.tio:1:185)

Questo sfrutta il debole typing ( 1=='1') di JavaScript per rilevare la lingua e le stesse parole chiave in Java e JavaScript ( var, class) e i costruttori di errori simili ( new Error()) per rendere il poliglotta.

PowerShell v6 e PowerShell v2, 73 byte

"This errors out in PowerShell v$($PSVersionTable.PSVersion) :P"
1-shl1/0

Provalo online!

Ciò genererà un errore di analisi su v2 perché è -shlstato introdotto in v3. v3 + sarà quindi in grado di spostare correttamente il valore prima di tentare di dividerlo per 0, generando un errore di divisione per zero. Entrambe le versioni hanno l'hashmap $ PSVersionTable che contiene il PSVersioncampo

C (gcc) su Linux / C (gcc) su Mac (160)

#include <sys/utsname.h>
main(){struct utsname n;float g;uname(&n);printf("This program errors out in C(gcc) on %s :P\n",n.sysname);g=1/(int)gamma(1);abort();}

Non testato su Mac; fondamentalmente, John Cook ha sottolineato (nel suo blog ) che POSIX non definisce la gamma; Linux utilizza il registro della funzione gamma (log (gamma (1)) restituirà 0 che attiverà un'eccezione in virgola mobile); OSX utilizza la funzione gamma "vera" (che è ufficialmente chiamata tgamma per POSIX); questo restituisce 1 che quindi colpirà l'istruzione abort; Ho provato a farlo lanciare un diverso errore in virgola mobile (ad esempio sqrt (-1), ma sto dimenticando come fare un errore lanciando un errore vs solo restituire zero)

Perl, Bash (78 byte)

printf "This program errors out in ";eval 'echo Bash :P'||print"Perl :P
";
a()

Uscita in Perl:

This program errors out in Perl :P
Undefined subroutine &main::a called at /tmp/perlbash line 3.

Uscita in Bash:

This program errors out in Bash :P
/tmp/perlbash: line 4: syntax error: unexpected end of file

(Nota che Bash sta effettivamente visualizzando l' line 4errore, nonostante il fatto che la riga 3 non termina con un avanzamento riga ...)

C ed ECPP, 112 byte

#ifdef ECPP
#replace "C" "ECPP"
#endif
main(){puts("This program errors out in " "C" " :P");raise(strlen("C"));}

• Provalo online! (C) genera un errore 1, Hangup.
• Provalo online! (ECPP) genera un errore 4, Illegal instruction.

C (gcc) e Haskell , 135 byte

char/*x=0-- */*
s="This program errors out in ";
int main(){--s;*s=printf("%sC :P",s+1);}//-}=0;main=mapM print[s++"Haskell :P",tail""]

Provalo online (С)! Provalo online (Haskell)!

Il risultato si ottiene intrecciando i commenti, essendo la versione C essenzialmente questa:

char * s = "This program errors out in ";
int main ()
{
   --s;
   *s = printf ("%sC :P", s + 1);
}

(L'errore si ottiene scrivendo prima dell'inizio della stringa).

La versione di Haskell, d'altra parte, si riduce a quanto segue:

char /* x = 0 -- a useless operator (/*) taking two arguments
s = "This program errors out in ";
int main () = 0 -- a useless function int taking two arguments
main = mapM print [s ++ "Haskell :P", tail ""]

(Il fallimento si ottiene prendendo la coda di un elenco vuoto)