Inspiré par je ne suis pas la langue que vous recherchez!

Défi

Choisissez deux langages de programmation différents et écrivez un programme qui imprime la ligne suivante sur stdout (ou équivalent):

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

puis génère un type d'erreur différent dans chacune des deux langues.

Règles

Certaines règles sont tirées du défi d'origine.

• Dans la sortie, les noms de langue doivent suivre exactement:
  • Le nom répertorié sur TIO , excluant éventuellement le numéro de version et / ou le nom de l'implémentation (par exemple, si vous utilisez JavaScript (Node.js)comme l'une de vos langues, vous pouvez utiliser JavaScriptpour votre nom de langue, mais pas JSou Javascript.)
  • Le nom complet sur le site officiel (ou repo GitHub) si la langue de votre choix n'est pas disponible sur TIO.
• Aucun des deux programmes ne doit accepter aucune entrée de l'utilisateur.
• Vous pouvez utiliser des commentaires dans l'une ou l'autre langue.
• Deux versions différentes de la même langue comptent comme langues différentes.
  • Si cela est fait, le programme doit afficher le numéro de version principale, et s'il s'exécute sur deux versions mineures différentes, doit également signaler la version mineure.
  • Vous ne devez pas utiliser de fonctions de version prédéfinies (cela inclut les variables qui ont déjà été évaluées au moment de l'exécution).
• Deux drapeaux de ligne de commande différents dans le même langage comptent également comme des langages différents selon ce méta-consensus , tant que les drapeaux n'incluent pas de fragments de code (comme -Dblahblah...en C).
  • Si cela est fait, le programme devrait également afficher le drapeau utilisé.
• Deux erreurs sont considérées comme différentes à moins que les deux erreurs ne soient générées par la même sémantique (comme «division par zéro», «défaut de segmentation» ou «index hors plage»).
  • Si le runtime d'une langue ne se termine pas après une erreur, mais signale l'erreur d'une manière ou d'une autre à l'utilisateur, c'est une erreur valide.
  • Si une langue ne discrimine pas les messages d'erreur mais possède une liste connue des raisons qui provoquent l'erreur, vous devez spécifier la raison, pas le message d'erreur.
    Un exemple est ><>, qui n'a qu'un seul message d'erreur something smells fishy..., mais la page wiki d'esolangs a une liste de raisons d'erreur.
• L'erreur de syntaxe n'est pas autorisée sauf si elle est générée par appel eval()ou similaire.
• Lancer quelque chose manuellement (via throw(JS), raise(Python), die(Perl) ou similaire) est autorisé, mais tous sont considérés comme un seul type d'erreur.
• L'erreur par commande invalide en 2D ou golflangs est également autorisée (et traitée comme une sorte d'erreur).

Exemples

Python et Ruby

• Python: This program errors out in Python :Pà stdout, puis identifiant non défini
• Ruby: This program errors out in Ruby :Pstdout, puis index hors limites

C89 et C99

• C89: This program errors out in C 89 :Pà stdout, puis division par zéro
• C99: This program errors out in C 99 :Pà stdout, puis défaut de segmentation

Notez que le numéro de version doit toujours être séparé du nom de la langue par un espace.

Python 2.7.9 et Python 2.7.10

• Python 2.7.9: This program errors out in Python 2.7.9 :Pvers stdout, puis erreur de syntaxe sur eval
• Python 2.7.10: This program errors out in Python 2.7.10 :Pà stdout, puis erreur de clé sur dict

Perl et Perl -n

• Perl: This program errors out in Perl :Pvers stdout, puis format d'heure invalide
• Perl -n: This program errors out in Perl -n :Ppour stdout, puis essayez d'ouvrir un fichier qui n'existe pas

Condition gagnante

Il s'agit de code-golf , donc le code le plus court en octets l'emporte. Mais vous êtes toujours encouragé à poster une réponse amusante ou intéressante même si elle n'est pas très courte.

Python 2 / Python 3 , 60 octets

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

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

Python 2:

• /est une division entière, 3/2 a 1; int (3/2 * 2) vaut 2.
• print est une instruction, donc la première instruction lue print((...)*1), *1signifie ici répéter la chaîne une fois.
• la deuxième instruction faisait référence à une variable inexistante, ce qui a provoqué l'erreur.
• Essayez-le en ligne!

Python 3:

• '/' est une division numérique flottante, 3/2 a obtenu 1,5; int (3/2 * 2) vaut 3.
• print est une fonction, donc la première instruction se lit comme (print(...))*1.
• printretourne la fonction None; La multiplication ne fonctionne pas None x int, elle signale donc "l'opérande non pris en charge".
• Essayez-le en ligne!

C et C ++, 114 101 octets

-13 octets grâce à l4m2 !

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

Erreur de segmentation en C ++, exception virgule flottante en C.

autoest par défaut inten C (int).5devient donc 0, donc essayer de diviser par elle est essentiellement une division par zéro.

En C ++ 1/dest 2, l'ajouter à l'adresse de det essayer de changer la valeur de cette adresse renvoie une erreur de segmentation.

Essayez-le en C ++!
Essayez-le en C!

JavaScript + HTML / HTML + JavaScript, 160 octets

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

Je ne sais pas si cela compte deux langues, mais c'est drôle.

Java 8 et C99, 172 octets

//\
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/**/;}}

Basé sur ma réponse pour le défi «abc» et «cba» .

Essayez-le en Java 8 - résultant en ArrayIndexOutOfBoundsException: 1 .
Essayez-le en C - entraînant une exception en virgule flottante: la division par zéro n'est pas définie .

Explication:

//\
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/**/;}}

Comme vous pouvez le voir dans le code surligné Java ci-dessus, la première ligne est un commentaire dû à //, et le code C est un commentaire dû à /* ... */, résultant en:

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

Il imprime donc sur STDOUT, puis essaie d'accéder au deuxième argument de programme (quand aucun n'est fourni), il produit donc l' exception 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/**/;}}

Je ne sais pas comment activer correctement la surbrillance C, car cela lang-centraîne la même surbrillance que Java .. Mais //\commentera la ligne suivante, qui est le code Java, résultant en:

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

Il imprime donc STDOUT, puis donne une division par zéro erreur.

Java 8 et espace blanc , 439 431 428 408 octets

                         






























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

Essayez-le en Java 8 - résultant en ArrayIndexOutOfBoundsException: 0 .
Essayez-le dans l'espace blanc - entraînant une erreur utilisateur (impossible de faire Infix Plus) .

Explication:

Java 8:

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

Il imprime donc sur STDOUT, puis essaie d'accéder au premier argument de programme (quand aucun n'est fourni), il produit donc l' exception ArrayIndexOutOfBoundsException .

Espace:

[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]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté à titre d'explication uniquement.

Essayez cette version surlignée.

Les espaces blancs sont un langage basé sur la pile qui ignore tout sauf les espaces, les tabulations et les nouvelles lignes. Voici le même programme en pseudo-code:

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

Il générera une erreur dès qu'il aura fini d'imprimer toutes les valeurs et que la pile sera vide lorsqu'il essaiera d' ajouter Add ( TSSS), ce qui nécessite deux éléments sur la pile.

J'ai généré la constante 111avec ce programme Java , que j'ai également utilisé pour les précédents défis liés à l'ASCII que j'ai faits dans Whitespace. De plus, j'ai utilisé quelques copies pour les espaces pour économiser des octets.

Une chose importante à noter est l'astuce que j'ai utilisée pour placer le programme Java dans la réponse Whitespace. Permettez-moi de commencer par expliquer comment un nombre est poussé dans l'espace blanc:

Sau début: activer la manipulation de la pile;
S: Appuyez sur ce qui suit comme nombre;
Sou T: positif ou négatif respectivement;
Certains Set / ou T, suivis d'un N: Numéro binaire, où T=1et S=0.

Voici quelques exemples:

• Pousser la valeur 1 sera SSSTN;
• Pousser la valeur -1 sera SSTTN;
• Pousser la valeur 111 sera SSSTTSTTTTN.
• Pousser la valeur 0 peut être SSSSN, SSTSN, SSSN, SSTN, SSSSSSSSSSSSN, etc. (Lorsque vous utilisez SSSN(ou SSTN), nous ne devons pas spécifier la partie binaire, car il est implicitement 0 après que nous avons fait part de son signe.)

Il SSSNsuffit donc de pousser la valeur 0(utilisée pour la lettre odans ce cas). Mais, pour placer le programme Java dans ce programme Whitespace golfé, j'avais besoin d'un espace supplémentaire, donc les deux premiers os sont poussés avec SSSN, mais le troisième est poussé avec SSSSN, nous avons donc suffisamment d'espace pour la phrase du programme Java.

CBM BASIC et code machine 6502 (C64), 142144 octets

J'ai dû ajouter 2 octets après avoir réalisé qu'une erreur de syntaxe n'était pas autorisée ....

Hexdump du .prgfichier:

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 vue CBM BASIC , telle que répertoriée dans l'éditeur du 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

Attention : Il est impossible de saisir correctement ce programme dans l'éditeur BASIC. N'essayez même pas de modifier ce programme dans l'éditeur BASIC, il plantera. C'est quand même un programme BASIC exécutable;)

Vue du code machine 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

Démo en ligne , tapezrunpour exécuter en BASIC,sys 2049pour exécuter en tant que code machine,listpour l'afficher interprété comme code BASIC.

L'exécution en tant que BASIC produit un division by zero error in 1, l'exécution en tant que code machine acan't continue error

Explication:

Les deux premiers octets d'un .prgfichier sont l'adresse de chargement en petit endian, c'est $0801(décimal 2049) ici, qui est l'adresse de début des programmes BASIC sur le C64. rundémarre ce programme dans l'interpréteur BASIC, tandis que sys 2049est la commande pour exécuter un programme de code machine à l'adresse 2049.

Comme vous pouvez le voir, la première ligne de la vue BASIC est un commentaire ( rem) contenant "garbage" et une partie de la chaîne de sortie requise. Il s'agit du programme de code machine et de certains octets de remplissage. Vous y voyez des commandes BASIC "aléatoires" car les programmes CBM-BASIC contiennent les commandes "tokenisées" en tant que valeurs à un octet, et certaines de ces valeurs sont les mêmes que les opcodes utilisés dans le code machine. Le code machine réutilise la chaîne présente dans la deuxième ligne de code pour sa sortie.

Les deux premiers octets d'une ligne d'un programme de base sont un pointeur vers la ligne suivante, ici $0850. Ceci est soigneusement choisi car 50 08une instruction de branche 6502 saute également sur les 8 octets suivants lorsque l'indicateur de débordement n'est pas défini - elle est utilisée pour sauter quelque part au milieu de cette ligne de "commentaire" lorsqu'elle est exécutée en tant que code machine. C'est 50l'opcode utilisé ici, donc la deuxième ligne doit commencer 0850pour que l'astuce fonctionne. C'est pourquoi vous voyez une séquence de 5 20octets (caractères d'espace) à remplir. Le code machine passe activement à la routine de gestion des erreurs ROM pour donner une erreur "ne peut pas continuer".

Le code BASIC est assez simple; comme deuxième argument pour "imprimer", deux variables non initialisées (ayant une valeur de 0dans CBM BASIC) sont divisées, déclenchant l'erreur "division par zéro".

> <> et Foo , 42 octets

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

Essayez-le dans> <>!

Essayez-le dans Foo!

Foo imprime tout ", comme cela est bien documenté, et essaie de diviser par zéro à la fin. Il ignore le '><>'.

><>pousse le "Foo" dans la pile, mais le fait immédiatement apparaître en utilisant p. Une fois qu'il a tout imprimé dans la pile, #o<il se ferme lorsque la pile est vide avec le seul message d'erreur qu'il connaît,something smells fishy...

C et Python, 126 116 octets

-10 octets grâce à @Bubbler!

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

En Python, print () est un None, donc essayer d'obtenir son négatif n'a pas de sens, donc Python lance une erreur.

En C, printf () renvoie un entier, donc le diviser par zéro donne une exception à virgule flottante.

Essayez-le en C!
Essayez-le en Python!

Attache + Wolfram Language (Mathematica) , 82 octets

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

Essayez Attache en ligne! Essayez Mathematica en ligne!

Cela dépend de la signification de l'opérateur = dans les deux langues. Dans Attache, il compare pour l'égalité, mais dans Mathematica, il effectue l'affectation des variables. :=fait l'affectation des variables dans les deux langues.

Maintenant, dans Attache, Printretourne un tableau de chaînes imprimées, et la soustraction n'est pas possible avec des chaînes et des entiers (à savoir, 0). Ainsi, une erreur de type est levée. Dans Mathematica, Printrenvoie Null, et Mathematica soustrait très bien 0de cela. Mais, nous lançons manuellement ce null avec Throw, donnant une nocatcherreur.

Python (2) et QB64 , 82 octets

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

Pour tester la version Python, vous pouvez L' essayer en ligne! Pour tester la version QB64, vous devrez télécharger QB64.

Ce que Python voit

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

La première ligne est juste l'expression nue 1(un no-op) suivie d'un commentaire.

La deuxième ligne définit sla chaîne "QB64", mais la troisième ligne la remplace immédiatement par "Python". La quatrième ligne imprime le message en conséquence.

La cinquième ligne est une autre expression nue, mais elle soulève un en NameErrorraison du nom non défini CLS.

Ce que voit le QB64

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

La première ligne, numérotée 1#, définit chaque variable dont le nom commence par S(insensible à la casse) en tant que variable chaîne. Cela signifie que nous n'avons pas à utiliser s$, ce qui serait une erreur de syntaxe en Python.

La deuxième ligne définit sla chaîne "QB64". 'démarre un commentaire dans QB64, donc la troisième ligne ne fait rien. La quatrième ligne imprime le message en conséquence.

La cinquième ligne essaie de CLS(effacer l'écran) avec un argument de -1. Mais depuis CLSaccepte que les arguments de 0, 1ou 2, ce produit l'erreur Illegal function call. L'erreur crée une boîte de dialogue demandant à l'utilisateur s'il souhaite continuer l'exécution ou abandonner. Techniquement, cela signifie que l'erreur n'est pas fatale (dans ce cas, vous pouvez choisir "continuer l'exécution" et le programme se termine simplement sans autres problèmes); mais l'OP a explicitement autorisé les langues qui peuvent continuer après une erreur, donc le comportement de QB64 devrait être correct.

Perl 5 et JavaScript (Node.js) , 96 octets

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

Cela utilise le fait que (...)c'est une liste en Perl quiprintf utilisera l'élément le plus à gauche de et le fait que c'est l'opérateur virgule en JavaScript, qui renverra l'argument le plus à droite.

Provoque une division par zéro d'erreur en Perl et une ReferenceError car $n'est pas définie en JavaScript.

Essayez le Perl en ligne!

Essayez le JavaScript en ligne!

Octave et MATLAB, 67 octets

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

Essayez-le en ligne!

Remarques: Le code suppose que MATLAB est installé sans boîte à outils (ou que les noms des boîtes à outils installées ne commencent pas par les lettres A à M).

Comment ça marche:

Le code obtient les données de version pour l'interpréteur et les boîtes à outils à l'aide ver. L'exécution v(1).Nameextrait le nom du premier produit, cela renverra soit OctaveouMATLAB supposant que la note ci-dessus est vraie.

Le programme affichera alors la chaîne requise, complétée par OctaveouMATLAB selon les besoins.

Enfin nous faisons v(--pi) .

Dans Octave, --est l'opérateur de pré-décrémentation. En tant que tel, il tente de pré-décrémenter ce qui échoue car la variable pin'existe pas ( piest en fait une fonction, pas une variable).

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

Dans MATLAB, l'opérateur de pré-décrémentation n'existe pas. En tant que telle, la déclaration est interprétée comme v(-(-pi))étant égale à juste v(pi). Cependant, pin'est pas un entier, il ne peut donc pas être utilisé pour indexer dans le vtableau, ce qui donne une erreur.

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

C ++ 14 (gcc) / C ++ 17 (gcc) , 107105 octets

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

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

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

Suppose que <cstdio>déclare printfdans l'espace de noms global (en plus de std) et que le jeu de caractères d'exécution de base utilise des valeurs ASCII, qui sont toutes les deux vraies en utilisant g ++ sur Linux.

Le piège de base ici est que C ++ 17 a éliminé les trigraphes du langage.

En C ++ 14, "??/0"contient un trigraphe et est équivalent à "\0". Il en *"??/0"va de même pour zéro et cest réglé sur zéro. Le nombre 4 est passé en argument à printf, puis la division par cprovoque un comportement indéfini. Sous Linux, cela se produit avant d' *pentrer dans l'image, et le programme obtient unSIGFPE .

En C ++ 17, "??/0"correspond exactement à la chaîne de longueur 4 qu'il semble être. Il en *"??/0"est de même pour '?'63 et cest défini sur 3. Le nombre 7 est passé en argument à printf, et cette fois la division par cest valide. Étant donné qu'il pest membre d'un espace de noms, il est initialisé à zéro au début du programme et possède une valeur de pointeur nulle, tout *pcomme le comportement non défini. Sous Linux, parce que le programme tente de modifier la mémoire à l'adresse zéro, le programme obtient un SIGSEGV.

Perl 5 et Perl 6 , 55 octets

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

Essayez Perl 5 en ligne! (Division illégale par zéro)

Essayez Perl 6 en ligne! (Pas une telle méthode)

Le préfixe ~est la stringification en Perl 6 et essentiellement un no-op dans le programme ci-dessus. En Perl 5, il n'est pas au niveau du bit, convertissant -1 en 0.

. est la syntaxe d'appel de méthode en Perl 6 et la concaténation en Perl 5.

C (gcc) / Stax , 109 octets

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

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

Essayez-le en ligne! (Stax) ou Exécuter et déboguer! (Stax)

Segfault dans C. Opération non valide dans Stax. J'adore la façon dont tout ce qui n'est pas un commentaire est réellement utilisé dans Stax.

C

C'est ainsi que C le voit. La première ligne est sans opération. La deuxième ligne imprime le message avec printfpuis segfaults en raison de la =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

Le programme Stax se termine chaque fois qu'il essaie de sauter ou de jeter un œil à partir d'une pile vide. Cela rend les choses un peu délicates et nous devons préparer une pile qui n'est pas vide. AA=~1;fait cela tout en restant une déclaration valide en 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 (**)

Ce qui est vraiment utile est le ~, il prépare une pile d'entrée non vide afin que le ;puisse être exécuté sans quitter le programme. Cependant, les deux1 s de la pile principale sont également utilisés ultérieurement.

La deuxième ligne commence par un onglet et commence un commentaire de ligne dans 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'opération non valide tente d'effectuer l' /opération pour une chaîne comme TOS (2e opérande) et le nombre1 de (*) en tant que 1er opérande, ce qui n'est pas valide.

Si les deux opérandes sont échangés, ce serait une opération valide dans Stax.

Gelée et M , 39 octets

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

Essayez-le dans Jelly!

Essayez-le en M!

Les deux langues s'appliquent à l'inverse İde 0ce qui donne infJelly et zooM. Je ne sais pas pourquoi zooreprésente l'infini chez M. Ask Dennis.

La différence importante est que l'infini de Jelly est égal à lui-même tandis que l'infini de M ne l'est pas. Ainsi la monade "est égale à elle-même" =`donne 1en gelée et 0en M. D'ici:

İ=`ị“¢³ƥ“Ȥ¹»;“ :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'erreur de Jelly est EOFError: EOF when reading a line.

L'erreur de M est TypeError: '>' not supported between instances of 'str' and 'int'.

Foo / CJam , 51 50 octets

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

Cela se termine avec une erreur de division par zéro dans Foo et une NumberFormatExceptiondans CJam.

À CJam:

• Un littéral de chaîne (entre guillemets) se propage dans la pile. Les éléments de la pile sont automatiquement imprimés sans séparateur à la fin du programme.
• /essaie de diviser la chaîne This program errors out in sur la sous-chaîne Foo. Étant donné que la chaîne ne contient pas la sous-chaîne, cela donne un tableau singleton contenant la chaîne d'origine, qui s'affiche exactement de la même manière.
• 'xest un littéral de caractère pour x, qui est imprimé de la même manière qu'une chaîne à un caractère. De cette façon, nous pouvons pousser des données pour CJam qui sont ignorées par Foo (je n'ai pas compris comment faire pour qu'une boucle ne s'exécute pas dans Foo).
• Litente de transtyper la chaîne vide en un entier, ce qui échoue. Tout de la pile est imprimé.

À Foo:

• Un littéral de chaîne (entre guillemets) s'imprime.
• / essaie de diviser la cellule actuelle par l'élément de pile supérieur (qui est implicite 0 ). Pour une raison quelconque, les erreurs de division par 0 ne sont pas fatales dans Foo, donc cela imprime simplement le message

  Only Chuck Norris can divide by zero.

  à STDERR et continue.
• Les caractères non reconnus ( 'C'J'a'met Li) sont ignorés.

Python et Lua , 111 110 102 98 95 85 octets

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

Erreurs: 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 ?

Clairement distinct.

Abuse de multiples différences:

• <var>=<a>,<b>,... crée un tuple en Python, mais dans Lua, il crée une liste d'arguments, à partir de laquelle seul le premier membre est pris.
• #démarre un commentaire en Python, mais est l'opérateur de longueur en Lua. Accessoires supplémentaires pour Python pour permettre aux tuples de se terminer par une virgule.
• [[...]]est la syntaxe de chaîne multiligne de Lua, ce qui signifie qu'elle ne voit même pas la fonction d'impression de Python; cela est nécessaire car Lua utilise ..la concaténation de chaînes et non +.
• Erreurs Python après avoir vu a, une variable indéfinie; Lua après z=#print(x.."Lua :P"). Utiliser juste #print(x.."Lua :P")pour Lua ne fonctionne pas, car cela soulève une erreur avant même que le code ne soit exécuté.

Modifications:

• Pas besoin d'utiliser "".join en Python, -1 octet
• Faites xune chaîne dans les deux langues et placezPython dans un littéral de chaîne dans la fonction d'impression, -8 octets
• L'utilisation #[[]]est plus courte que #""et --[[]], -4 octets
• Pas besoin d'utiliser #1comme clé de table, -3 octets
• Jo roi a fait ce , -9 octets
• Prendre la longueur de la valeur de retour des print(x.."Lua :P")œuvres, apparemment; -1 octet

Java et 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]/**/;}}

Abuser de la gestion des différents échappements entre java et C # (les échappements unicode sont analysés avant l'analyse du code en java et non en c #) comme une sorte de préprocesseur, c'est le travail du \u0027 magie, le reste sont des "commentaires à bascule"

Edit: Golfé de 8 octets grâce à un pointeur de @KevinCruijssen

Edit: règle derp fixe

AutoHotKey / C #, 155 133 128 122 octets

La mise en évidence de la syntaxe l'explique mieux que moi:

C # RuntimeBinderException: 'Impossible d'appeler un type non délégué'

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

Erreur AutoHotkey : une exception a été levée.

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

Modifications:

1. supprimé un var
2. -5 octets grâce à lait

PHP 7+ / JavaScript, 90 89 octets

Celui-ci utilise 2 langues avec une syntaxe très similaire, permettant d'écrire ce code sur les deux langues.

La séparation du langage se fait par une propriété non présente en JavaScript: PHP considère [](tableau vide) comme une valeur fausse alors qu'il est véridique en JavaScript (car c'est un objet et les objets sont toujours véridiques, même new Boolean(false)).

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

Exécution:

Se concentrera sur le morceau de code suivant: ([]?console.log($X,'JavaScript'):printf($X,PHP))();.

L'attribution de chaîne fonctionne de la même manière dans les deux langues.

Ce code utilise "l'opérateur ternaire" ( Javascript , PHP ), qui fonctionne principalement de la même manière dans les deux langues.

Javascript

Javascript exécutera la console.log($X,'JavaScript')pièce, qui revient undefined.

Plus tard, lorsque vous essayez d'exécuter (...)() , vous obtenez unUncaught TypeError: (intermediate value)(intermediate value)(intermediate value) is not a function (dans Google Chrome).

PHP

PHP exécutera le printf($X,PHP) pièce.

En PHP, la printffonction renvoie la longueur de la sortie .

PHP a une fonctionnalité intéressante: il peut exécuter des fonctions dont le nom est stocké dans une variable (ou, depuis PHP7, comme résultat d'une expression), ce qui évite une erreur de syntaxe.

PHP tentera alors d'exécuter la fonction dont le nom est le résultat de l'expression []? ... :printf($X,PHP)(qui est le nombre 33).
Mais cette fonctionnalité intéressante a une mise en garde: accepte uniquement les chaînes (duh!).

Cela provoque un Fatal error: Function name must be a string, car 33est un int.

Merci à Shieru Asakoto de m'avoir sauvé 1 octet!

Perl 5 et C, 95 octets

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

//; est fondamentalement un NOP en perl, et est un commentaire en C.

Le programme C est donc effectivement:

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

Qui imprime la chaîne requise, puis essaie de s'exécuter puts(32). Il s'agit d'un comportement techniquement indéfini en C, mais il provoque une erreur de segmentation sur TIO et tous les systèmes auxquels j'ai accès.

Le programme perl traite l'ensemble du programme C comme une chaîne, utilise l'expression régulière /T.*n /pour correspondre This program errors out in, puis imprime cela et perl :P. dieprovoque le programme à planter avec l'erreur Died at script_name line 2.

Si vous n'aimez pas cela comme une erreur, 1/0c'est la même longueur et plante avec une Illegal division by zeroerreur. J'aime juste dieplus;)

Essayez-le en ligne! (C)

Essayez-le en ligne! (Perl)

VBScript, JScript, 72 octets

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

VBScript affichera "Erreur d'exécution Microsoft VBScript: incompatibilité de type: 'y'"
JScript affichera "Erreur d'exécution Microsoft JScript: 'y' n'est pas défini"

JavaScript et Python 3, 105 91 octets

Erreurs par NameError: name 'console' is not defineden Python 3

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

Essayez-le en ligne!

... et par TypeError: console.log(...) is not a functionen JavaScript.

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

Essayez-le en ligne!

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

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");}}}

Essayez-le en ligne! (Java)

Essayez-le en ligne! (JavaScript)

Sortie en Java:

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

Sortie en JavaScript (vers stderr):

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

Cela profite du faible typage de JavaScript ( 1=='1') pour détecter le langage, et des mêmes mots clés en Java et JavaScript ( var, class), et des constructeurs d'erreur similaires ( new Error()) pour rendre le polyglotte.

PowerShell v6 et PowerShell v2, 73 octets

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

Essayez-le en ligne!

Cela générera une erreur d'analyse sur la v2 car elle a -shlété introduite dans la v3. v3 + pourra alors décaler correctement la valeur avant d'essayer de la diviser par 0, générant ainsi une erreur de division par zéro. Les deux versions ont la table de hachage $ PSVersionTable qui contient le PSVersionchamp

C (gcc) sur Linux / C (gcc) sur 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 testé sur Mac; en gros, John Cook a souligné (dans son blog ) que POSIX ne définit pas le gamma; Linux utilise le journal de la fonction gamma (log (gamma (1)) renverra 0, ce qui déclenchera une exception à virgule flottante); OSX utilise la "vraie" fonction gamma (qui est officiellement appelée tgamma par POSIX); cela renvoie 1 qui frappera alors l'instruction d'abandon; J'ai essayé de lui faire lancer une erreur en virgule flottante différente (par exemple sqrt (-1) mais j'oublie comment faire ce lancer une erreur vs simplement retourner zéro)

Perl, Bash (78 octets)

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

Sortie en Perl:

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

Sortie en Bash:

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

(Notez que Bash affiche en effet l' line 4erreur, malgré le fait que la ligne 3 ne se termine pas par un saut de ligne ...)

C et ECPP, 112 octets

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

• Essayez-le en ligne! (C) Lance erreur 1, Hangup.
• Essayez-le en ligne! (ECPP) Lance erreur 4, Illegal instruction.

C (gcc) et Haskell , 135 octets

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""]

Essayez-le en ligne (С)! Essayez-le en ligne (Haskell)!

Le résultat est obtenu en imbriquant les commentaires, la version C étant essentiellement la suivante:

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

(L'échec est obtenu en écrivant avant le début de la chaîne).

La version Haskell, en revanche, se réduit à ce qui suit:

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 ""]

(L'échec est obtenu en prenant la queue d'une liste vide)