¡Inspirado por no soy el idioma que estás buscando!

Reto

Elija dos lenguajes de programación diferentes y escriba un programa que imprima la siguiente línea en stdout (o equivalente):

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

y luego genera diferentes tipos de error en cada uno de los dos idiomas.

Reglas

Algunas reglas se toman del desafío original.

• En la salida, los nombres de los idiomas deben seguir exactamente:
  • El nombre que figura en TIO , excluyendo opcionalmente el número de versión y / o el nombre de implementación (por ejemplo, si lo usa JavaScript (Node.js)como uno de sus idiomas, puede usarlo JavaScriptpara su nombre de idioma, pero no JSo Javascript).
  • El nombre completo en el sitio web oficial (o repositorio de GitHub) si su idioma de elección no está disponible en TIO.
• Ninguno de los programas debe recibir ninguna entrada del usuario.
• Puede usar comentarios en cualquier idioma.
• Dos versiones diferentes del mismo idioma cuentan como idiomas diferentes.
  • Si se hace esto, el programa debería generar el número de versión principal y, si se ejecuta en dos versiones menores diferentes, también debería informar la versión menor.
  • No debe usar funciones de versión preconstruidas (esto incluye variables que ya se han evaluado en tiempo de ejecución).
• Dos banderas de línea de comando diferentes en el mismo idioma también cuentan como idiomas diferentes según este meta consenso , siempre que las banderas no incluyan fragmentos de código (como -Dblahblah...en C).
  • Si se hace esto, el programa también debería generar la bandera utilizada.
• Dos errores se consideran diferentes a menos que ambos errores sean generados por la misma semántica (como "división por cero", "falla de segmentación" o "índice fuera de rango").
  • Si el tiempo de ejecución de un idioma no se cierra después de un error, pero informa el error de alguna manera al usuario, es un error válido.
  • Si un idioma no discrimina los mensajes de error pero tiene una lista conocida de los motivos que causan el error, debe especificar el motivo, no el mensaje de error.
    Un ejemplo es ><>, que tiene un solo mensaje de error something smells fishy..., pero la página wiki de esolangs tiene una lista de razones de error.
• El error de sintaxis no está permitido a menos que se genere mediante una llamada eval()o similar.
• Lanzar algo manualmente (a través de throw(JS), raise(Python), die(Perl) o similar) está permitido, pero todos se consideran un tipo de error.
• También se permite el error por comando no válido en 2D o golflangs (y se trata como un tipo de error).

Ejemplos

Python y Ruby

• Python: This program errors out in Python :Pa stdout, luego identificador indefinido
• Ruby: This program errors out in Ruby :Ppara stdout, luego indexar fuera de límites

C89 y C99

• C89: This program errors out in C 89 :Pa stdout, luego división por cero
• C99: This program errors out in C 99 :Pa stdout, luego falla de segmentación

Tenga en cuenta que el número de versión siempre debe estar separado del nombre del idioma por un espacio.

Python 2.7.9 y Python 2.7.10

• Python 2.7.9: This program errors out in Python 2.7.9 :Pa stdout, luego error de sintaxis en eval
• Python 2.7.10: This program errors out in Python 2.7.10 :Pa stdout, luego error clave en dict

Perl y Perl -n

• Perl: This program errors out in Perl :Pa stdout, luego formato de hora no válido
• Perl -n: This program errors out in Perl -n :Ppara stdout, luego intente abrir un archivo que no existe

Condición ganadora

Este es el código de golf , por lo que gana el código más corto en bytes. Pero siempre se le anima a publicar una respuesta que sea divertida o interesante, incluso si no es muy corta.

Python 2 / Python 3 , 60 bytes

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

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

Python 2:

• /es división entera, 3/2 tiene 1; int (3/2 * 2) es 2.
• print es una declaración, por lo que la primera declaración leída como print((...)*1), aquí *1significa repetir la cadena una vez.
• La segunda declaración hacía referencia a una variable no existente, que causó el error.
• Pruébalo en línea!

Python 3:

• '/' es una división de números flotantes, 3/2 obtuvo 1.5; int (3/2 * 2) es 3.
• print es una función, por lo que la primera instrucción se lee como (print(...))*1.
• la función printvuelve None; La multiplicación no funciona None x int, por lo que informa "operando no compatible".
• Pruébalo en línea!

C y C ++, 114 101 bytes

-13 bytes gracias a l4m2 !

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

Falla de segmentación en C ++, excepción de coma flotante en C.

autoestá predeterminado inten C, entonces se (int).5convierte 0, por lo que tratar de dividirlo es básicamente división entre cero.

En C ++ 1/des 2, agregarlo a la dirección de intentar cambiar el valor de esa dirección arroja un defecto.

¡Pruébalo en C ++!
Pruébalo en C!

JavaScript + HTML / HTML + JavaScript, 160 bytes

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

No estoy seguro si esto cuenta dos idiomas, pero es divertido.

Java 8 y C99, 172 bytes

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

Basado en mi respuesta para el desafío 'abc' y 'cba' .

Pruébelo en Java 8, lo que resulta en ArrayIndexOutOfBoundsException: 1 .
Pruébelo en C, lo que da como resultado una excepción de punto flotante: la división por cero no está definida .

Explicación:

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

Como puede ver en el código resaltado de Java anterior, la primera línea es un comentario debido //, y el código C es un comentario debido /* ... */, lo que resulta en:

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

Por lo tanto, se imprime en STDOUT y luego intenta acceder al segundo argumento de programa (cuando no se proporciona ninguno), por lo que produce la excepción 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/**/;}}

No estoy seguro de cómo habilitar correctamente el resaltado en C, porque lang-cda como resultado el mismo resaltado que Java ... Pero //\comentará la siguiente línea, que es el código Java, lo que resulta en:

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

Entonces se reduce a STDOUT, y luego da una división por cero error.

Java 8 y espacios en blanco , 439 431 428 408 bytes

                         






























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

Pruébelo en Java 8, lo que da como resultado ArrayIndexOutOfBoundsException: 0 .
Pruébelo en espacios en blanco: se produce un error del usuario (No se puede hacer Infix Plus) .

Explicación:

Java 8:

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

Por lo tanto, imprime en STDOUT y luego intenta acceder al primer argumento de programa (cuando no se proporciona ninguno), por lo que produce la excepción ArrayIndexOutOfBoundsException .

Espacio en blanco:

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

Se agregaron letras S(espacio), T(tabulación) y N(nueva línea) solo como resaltado.
[..._some_action]agregado solo como explicación.

Prueba esta versión resaltada.

El espacio en blanco es un lenguaje basado en la pila que ignora todo excepto los espacios, las pestañas y las nuevas líneas. Aquí está el mismo programa en pseudocódigo:

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

Se producirá un error tan pronto como termine de imprimir todos los valores y la pila esté vacía cuando intente hacer Add ( TSSS), que requiere dos elementos en la pila.

He generado la constante 111con este programa Java , que también he usado para desafíos anteriores relacionados con ASCII que hice en Whitespace. Además, he usado algunas copias de los espacios para guardar bytes.

Una cosa importante a tener en cuenta es el truco que he usado para colocar el programa Java dentro de la respuesta de espacios en blanco. Permítanme comenzar explicando cómo se empuja un número en el espacio en blanco:

Sal principio: Habilite la manipulación de pila;
S: Presione lo que sigue como Número;
So T: Positivo o Negativo respectivamente;
Algunos Sy / o T, seguido de un N: Número como binario, donde T=1y S=0.

Aquí algunos ejemplos:

• Empujar el valor 1 será SSSTN;
• Empujar el valor -1 será SSTTN;
• Empujar el valor 111 será SSSTTSTTTTN.
• Empujar el valor puede ser 0 SSSSN, SSTSN, SSSN, SSTN, SSSSSSSSSSSSN, etc. (Cuando se utiliza SSSN(o SSTN), no tenemos que especificar la parte binaria, porque es implícitamente 0 después de haber manifestado su signo.)

Tan solo SSSNes suficiente para empujar el valor 0(utilizado para la letra oen este caso). Pero, para colocar el programa Java en este programa de espacios en blanco golfizado, necesitaba un espacio adicional, por lo que ose presionan los primeros dos s SSSN, pero se presiona el tercero SSSSN, por lo que tenemos suficientes espacios para la oración del programa Java.

CBM BASIC y código de máquina 6502 (C64), 142 144 bytes

Tuve que agregar 2 bytes después de darse cuenta de que un error de sintaxis no estaba permitido ...

Hexdump de .prgarchivo:

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 BÁSICA CBM , como se muestra en el 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

Atención : es imposible ingresar correctamente este programa en el editor BASIC. Ni siquiera intentes editar este programa en el editor BASIC, se bloqueará. Aún así, es un programa BASIC ejecutable;)

La vista de código de máquina 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

Demostración en línea , escribarunpara ejecutar como BASIC,sys 2049para ejecutar como código de máquina,listpara mostrarlo interpretado como código BASIC.

Ejecutar como BASIC produce division by zero error in 1uncan't continue error

Explicación:

Los primeros dos bytes de un .prgarchivo son la dirección de carga en little endian, aquí es $0801(decimal 2049), que es la dirección de inicio de los programas BASIC en el C64. runinicia este programa en el intérprete BASIC, mientras que sys 2049es el comando para ejecutar un programa de código de máquina en la dirección 2049.

Como puede ver, la primera línea en la vista BÁSICA es un comentario ( rem) que contiene "basura" y parte de la cadena de salida requerida. Este es el programa de código de máquina y algunos bytes de relleno. Verá algunos comandos BASIC "aleatorios" porque los programas CBM-BASIC contienen los comandos "tokenizados" como valores de un solo byte, y algunos de estos valores son los mismos que los códigos de operación utilizados en el código de máquina. El código de máquina reutiliza la cadena presente en la segunda línea de código para su salida.

Los primeros dos bytes de una línea de un programa básico son un puntero a la siguiente línea, aquí $0850. Esto se elige cuidadosamente porque 50 08también es una instrucción de bifurcación 6502 que salta sobre los siguientes 8 bytes cuando no se establece el indicador de desbordamiento; esto se usa para saltar en algún lugar en el medio de esta línea de "comentario" cuando se ejecuta como código de máquina. El 50es el código de operación utilizado aquí, por lo que la segunda línea tiene que comenzar 0850para que el truco funcione. Es por eso que ve una secuencia de 5 20bytes (caracteres de espacio) para completar. El código de máquina salta activamente a la rutina de manejo de errores de ROM para dar un error de "no puede continuar".

El código BÁSICO es bastante sencillo; Como segundo argumento para "imprimir", 0se dividen dos variables no inicializadas (que tienen un valor de en CBM BASIC), lo que provoca el error "división por cero".

> <> y Foo , 42 bytes

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

Pruébalo en> <>!

Pruébalo en Foo!

Foo imprime todo ", como está bien documentado, e intenta dividir por cero al final. Ignora el '><>'.

><>empuja el "Foo" a la pila, pero inmediatamente lo saca usando p. Después de que imprime todo en la pila #o<, sale cuando la pila está vacía con el único mensaje de error que conoce,something smells fishy...

C y Python, 126116 bytes

-10 bytes gracias a @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 () es un None, por lo que tratar de obtener su negativo no tiene sentido, por lo que Python arroja un error.

En C printf () devuelve un int, entonces dividirlo por cero da una excepción de coma flotante.

Pruébalo en C!
¡Pruébalo en Python!

Attache + Wolfram Language (Mathematica) , 82 bytes

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

¡Prueba Attache en línea! ¡Prueba Mathematica en línea!

Esto gira sobre el significado del operador =en los dos idiomas. En Attache, compara la igualdad, pero en Mathematica, realiza la asignación de variables. :=realiza asignaciones variables en ambos idiomas.

Ahora, en Attache, Printdevuelve una matriz de cadenas impresas, y la sustracción no es posible con cadenas y enteros (es decir, 0). Entonces, se produce un error de tipo. En Mathematica, Printretornos Null, y Mathematica está muy bien restando 0de eso. Pero, tiramos manualmente ese nulo con Throw, dando un nocatcherror.

Python (2) y QB64 , 82 bytes

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

Para probar la versión de Python, ¡puede probarla en línea! Para probar la versión QB64, deberá descargar QB64.

Lo que ve Python

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

La primera línea es solo la expresión desnuda 1(un no-op) seguida de un comentario.

La segunda línea se establece sen la cadena "QB64", pero la tercera línea la cambia inmediatamente a "Python". La cuarta línea imprime el mensaje en consecuencia.

La quinta línea es otra expresión desnuda, pero plantea un NameErrorpor el nombre indefinido CLS.

Lo que ve QB64

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

La primera línea, numerada 1#, define cada variable cuyo nombre comienza con S(sin distinción entre mayúsculas y minúsculas) como una variable de cadena. Esto significa que no tenemos que usar s$, lo que sería un error de sintaxis en Python.

La segunda línea se establece sen la cadena "QB64". 'comienza un comentario en QB64, por lo que la tercera línea no hace nada. La cuarta línea imprime el mensaje en consecuencia.

La quinta línea intenta CLS(borrar la pantalla) con un argumento de -1. Pero ya que CLSsólo acepta los argumentos de 0, 1o 2, lo que produce el error Illegal function call. El error crea un cuadro de diálogo que le pregunta al usuario si desea continuar con la ejecución o abortar. Técnicamente, esto significa que el error no es fatal (en este caso, puede elegir "continuar ejecución" y el programa simplemente termina sin más problemas); pero el OP ha permitido explícitamente idiomas que pueden continuar después de un error, por lo que el comportamiento de QB64 debería estar bien.

Perl 5 y JavaScript (Node.js) , 96 bytes

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

Esto hace uso del hecho de que (...)es una lista en Perl que printfusará el elemento más a la izquierda y el hecho de que es el operador de coma en JavaScript, que devolverá el argumento más a la derecha.

Provoca un error de división por cero en Perl y un Error de referencia porque $no está definido en JavaScript.

Prueba el Perl en línea!

¡Prueba el JavaScript en línea!

Octava y MATLAB, 67 bytes

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

Pruébalo en línea!

Notas: El código asume que MATLAB está instalado sin cajas de herramientas (o que los nombres de cualquier caja de herramientas instalada no comienzan con las letras A a M).

Cómo funciona:

El código obtiene los datos de la versión para el intérprete y las cajas de herramientas que utilizan ver. Running v(1).Nameextrae el nombre del primer producto, esto devolverá Octaveo MATLABsuponiendo que la nota anterior sea cierta.

El programa mostrará la cadena requerida, completa con Octaveo MATLABsegún sea necesario.

Finalmente lo hacemos v(--pi).

En Octave, --es el operador de pre-decremento. Como tal, intenta pre-decrementar lo que falla ya que la variable pino existe (en pirealidad es función, no una variable).

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

En MATLAB, el operador de decremento previo no existe. Como tal, la declaración se interpreta como v(-(-pi))que es igual a justo v(pi). Sin embargo, pino es un número entero, por lo que no se puede usar para indexar en la vmatriz, dando un error.

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

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

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

Pruébalo en línea! (C ++ 14)

Pruébalo en línea! (C ++ 17)

Supone que <cstdio>declara printfen el espacio de nombres global (además de std) y que el conjunto de caracteres de ejecución básica usa valores ASCII, que son ciertos usando g ++ en Linux.

El problema básico aquí es que C ++ 17 eliminó los trigrafos del lenguaje.

En C ++ 14, "??/0"contiene un trigrafo y es equivalente a "\0". Entonces *"??/0"es cero, y cse establece en cero. El número 4 se pasa como argumento a printf, luego la división por ccausa un comportamiento indefinido. En Linux, esto sucede antes de que *pentre en escena y el programa obtiene un SIGFPE.

En C ++ 17, "??/0"es exactamente la longitud de 4 cadenas que parece ser. Así *"??/0"es '?'o 63, y cse establece en 3. El número 7 se pasa como argumento a printf, y esta vez la división por ces válida. Dado que pes un miembro del espacio de nombres, se inicializa a cero al inicio del programa y tiene un valor de puntero nulo, por lo que *pes un comportamiento indefinido. En Linux, debido a que el programa intenta modificar la memoria en la dirección cero, el programa obtiene un SIGSEGV.

Perl 5 y Perl 6 , 55 bytes

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

¡Prueba Perl 5 en línea! (División ilegal por cero)

¡Prueba Perl 6 en línea! (No existe tal método)

El prefijo ~es stringificación en Perl 6 y esencialmente un no-op en el programa anterior. En Perl 5, no es bit a bit, convirtiendo -1 a 0.

. es la sintaxis de llamada al método en Perl 6 y la concatenación en Perl 5.

C (gcc) / Stax , 109 bytes

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

Pruébalo en línea! (C (gcc))

Pruébalo en línea! (Stax) o Ejecutar y depurarlo! (Stax)

Segfault en C. Operación no válida en Stax. Me encanta cómo todo lo que no es un comentario se usa realmente en Stax.

do

Así es como C lo ve. La primera línea es no-op. La segunda línea imprime el mensaje con printfy luego segfaults debido a =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

El programa Stax termina cada vez que intenta saltar o echar un vistazo desde la pila vacía. Esto lo hace un poco complicado y tenemos que preparar una pila que no esté vacía. AA=~1;hace esto sin dejar de ser una declaración válida 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 (**)

Lo que es realmente útil es ~que prepara una pila de entrada no vacía para que ;se pueda ejecutar sin salir del programa. Sin embargo, los dos 1s en la pila principal también se usan más tarde.

La segunda línea comienza con una pestaña y comienza un comentario de línea en 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

La operación no válida está intentando realizar una /operación para una cadena como TOS (segundo operando) y el número 1de (*) como primer operando, que no es válido.

Si se intercambian los dos operandos, sería una operación válida en Stax.

Jelly and M , 39 bytes

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

Pruébalo en gelatina!

Pruébalo en M!

Ambas lenguas se aplican inversa İa 0la que da lugar infa la jalea y zoode M. no sé qué zoorepresenta el infinito en M. Pregunta Dennis.

La diferencia importante es que el infinito de Jelly es igual a sí mismo, mientras que el infinito de M no lo es. Así, la mónada "es igual a sí misma" =`rinde 1en Jelly y 0en M. A partir de aquí:

İ=`ị“¢³ƥ“Ȥ¹»;“ :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

El error de Jelly es EOFError: EOF when reading a line.

El error de M es TypeError: '>' not supported between instances of 'str' and 'int'.

Foo / CJam , 51 50 bytes

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

Esto sale con un error de división por cero en Foo, y a NumberFormatExceptionen CJam.

A CJam:

• Un literal de cadena (entre comillas) se empuja a la pila. Los elementos de la pila se imprimen automáticamente sin un separador cuando finaliza el programa.
• /intenta dividir la cadena This program errors out in en la subcadena Foo. Dado que la cadena no contiene la subcadena, esto produce una matriz singleton que contiene la cadena original, que se muestra exactamente de la misma manera.
• 'x es un carácter literal para x , que se imprime de la misma manera que una cadena de un carácter. De esta manera, podemos enviar datos para CJam que Foo ignora (no he descubierto cómo hacer que un bucle no se ejecute en Foo).
• Liintenta convertir la cadena vacía en un entero, que falla. Todo de la pila está impreso.

Para Foo:

• Se imprime un literal de cadena (entre comillas).
• / intenta dividir la celda actual por el elemento de la pila superior (que es un implícito 0 ). Por alguna razón, los errores de división por 0 no son fatales en Foo, por lo que esto solo imprime el mensaje

  Only Chuck Norris can divide by zero.

  STDERR y sigue adelante.
• Los caracteres no reconocidos ( 'C'J'a'my Li) se ignoran.

Python y Lua , 111 110 102 98 95 85 bytes

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

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

Claramente distinto.

Abusa de múltiples diferencias:

• <var>=<a>,<b>,... crea una tupla en Python, pero en Lua crea una lista de argumentos, de la que solo se toma el primer miembro.
• #comienza un comentario en Python, pero es el operador de longitud en Lua. Accesorios adicionales para Python para permitir que las tuplas terminen en una coma.
• [[...]]es la sintaxis de cadena multilínea de Lua, lo que significa que ni siquiera ve la función de impresión de Python; esto es necesario debido a que Lua usa la ..concatenación de cadenas y no+ .
• Errores de Python después de ver a, una variable indefinida; Lua después z=#print(x.."Lua :P"). Usar solo #print(x.."Lua :P")para Lua no funciona, ya que genera un error incluso antes de que se ejecute el código.

Ediciones:

• No es necesario usar "".joinen Python, -1 byte
• Haga xuna cadena en ambos idiomas y colóquela Pythonen una cadena literal en la función de impresión, -8 bytes
• El uso #[[]]es más corto que #""y--[[]] , -4 bytes
• No es necesario usar #1como clave de tabla, -3 bytes
• Jo King hizo esto , -9 bytes
• Tomando la longitud del valor de retorno de las print(x.."Lua :P")obras, aparentemente; -1 byte

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

Abusar de diferentes manejos de escape entre Java y C # (los escapes Unicode se analizan antes del análisis de código en Java y no en C #) como una especie de preprocesador, ese es el trabajo del \u0027 magia, el resto son algunos "comentarios de alternancia"

Editar: Golfed 8 bytes gracias a un puntero de @KevinCruijssen

Editar: regla derp fija

AutoHotKey / C #, 155 133 128 122 bytes

El resaltado de sintaxis lo explica mejor de lo que podría:

C # RuntimeBinderException: 'No se puede invocar un tipo no delegado'

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

Error de AutoHotkey : se produjo una excepción.

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

Ediciones:

1. eliminado una var
2. -5 bytes gracias a la leche

PHP 7+ / JavaScript, 90 89 bytes

Utiliza 2 idiomas con una sintaxis muy similar, lo que permite escribir este código en ambos idiomas.

La separación del lenguaje se realiza mediante una propiedad no presente en JavaScript: PHP considera [](matriz vacía) un valor falso mientras es verdadero en JavaScript (porque es un objeto y los objetos son siempre verdaderos, incluso new Boolean(false)).

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

Ejecución:

Se centrará en el siguiente fragmento de código: ([]?console.log($X,'JavaScript'):printf($X,PHP))();.

La atribución de cadena funciona igual en ambos idiomas.

Este código utiliza el "operador ternario" ( Javascript , PHP ), que funciona principalmente de la misma manera en ambos idiomas.

Javascript

Javascript ejecutará la console.log($X,'JavaScript')pieza, que vuelve undefined.

Más adelante, cuando intentas ejecutar (...)(), obtienes unUncaught TypeError: (intermediate value)(intermediate value)(intermediate value) is not a function (en Google Chrome).

PHP

PHP ejecutará la printf($X,PHP)pieza.

En PHP, la printffunción devuelve la longitud de la salida .

PHP tiene una funcionalidad interesante: puede ejecutar funciones cuyo nombre se almacena en una variable (o, desde PHP7, como resultado de una expresión), lo que evita un error de sintaxis.

Entonces PHP intentará ejecutar la función cuyo nombre es el resultado de la expresión []? ... :printf($X,PHP)(que es el número 33).
Pero esa funcionalidad interesante tiene una advertencia: solo acepta cadenas (¡duh!).

Esto causa un Fatal error: Function name must be a string, porque 33es un int.

¡Gracias a Shieru Asakoto por salvarme 1 byte!

Perl 5 y C, 95 bytes

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

//; es básicamente un NOP en perl, y es un comentario en C.

Entonces el programa C es efectivamente:

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

Que imprime la cadena requerida, luego intenta ejecutarse puts(32). Este es un comportamiento técnicamente indefinido en C, pero causa una falla de segmentación en TIO y en todos los sistemas a los que tengo acceso.

El programa perl trata todo el programa C como una cadena, usa la expresión regular /T.*n /para que coincida This program errors out iny luego imprime eso y perl :P. diehace que el programa se bloquee con el error Died at script_name line 2.

Si no le gusta eso como un error, 1/0tiene la misma longitud y se bloquea con un Illegal division by zeroerror. Simplemente me gusta diemás;)

Pruébalo en línea! (DO)

Pruébalo en línea! (Perl)

VBScript, JScript, 72 bytes

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

VBScript imprimirá "Error de tiempo de ejecución de Microsoft VBScript: No coincide el tipo: 'y'"
JScript imprimirá "Error de tiempo de ejecución de Microsoft JScript: 'y' no está definido"

JavaScript y Python 3, 105 91 bytes

Errores por 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")()

Pruébalo en línea!

... y 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")()

Pruébalo en línea!

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

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

Pruébalo en línea! (Java)

Pruébalo en línea! (JavaScript)

Salida en Java:

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

Salida en JavaScript (a stderr):

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

Esto aprovecha el tipeo débil de JavaScript ( 1=='1') para detectar el lenguaje, y las mismas palabras clave en Java y JavaScript ( var, class), y los constructores de error similares ( new Error()) para hacer el políglota.

PowerShell v6 y PowerShell v2, 73 bytes

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

Pruébalo en línea!

Esto arrojará un error de análisis en v2 porque -shlse introdujo en v3. v3 + podrá cambiar correctamente el valor antes de intentar dividirlo por 0, arrojando convenientemente un error de división por cero. Ambas versiones tienen el hashmap $ PSVersionTable que contiene el PSVersioncampo

C (gcc) en Linux / C (gcc) en 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();}

No probado en Mac; básicamente, John Cook señaló (en su blog ) que POSIX no define gamma; Linux usa el registro de la función gamma (log (gamma (1)) devolverá 0, lo que desencadenará una excepción de coma flotante); OSX usa la función gamma "verdadera" (que oficialmente se llama tgamma por POSIX); esto devuelve 1 que luego golpeará la declaración abortar; Traté de hacer que arrojara un error de coma flotante diferente (por ejemplo, sqrt (-1) pero me estoy olvidando de cómo hacer que arroje un error frente a solo devolver cero)

Perl, Bash (78 bytes)

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

Salida en Perl:

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

Salida en Bash:

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

(Tenga en cuenta que Bash está mostrando el line 4error, a pesar de que la línea 3 no termina con un avance de línea ...)

C y ECPP, 112 bytes

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

• Pruébalo en línea! (C) Lanza error 1, Hangup.
• Pruébalo en línea! (ECPP) Lanza error 4, Illegal instruction.

C (gcc) y Haskell , 135 bytes

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

¡Pruébelo en línea (С)! ¡Pruébelo en línea (Haskell)!

El resultado se logra entretejiendo los comentarios, siendo la versión C esencialmente esta:

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

(La falla se logra escribiendo antes del comienzo de la cadena).

La versión de Haskell, por otro lado, se reduce a lo siguiente:

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

(El fracaso se logra tomando la cola de una lista vacía)