Inspirado por eu não sou o idioma que você está procurando!

Desafio

Escolha duas linguagens de programação diferentes e escreva um programa que imprima a seguinte linha em stdout (ou equivalente):

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

e, em seguida, gera um tipo diferente de erro em cada um dos dois idiomas.

Regras

Algumas regras são retiradas do desafio original.

• Na saída, os nomes dos idiomas devem seguir exatamente:
  • O nome listado no TIO , opcionalmente excluindo o número da versão e / ou o nome da implementação (por exemplo, se você usar JavaScript (Node.js)como um dos seus idiomas, poderá usar JavaScripto nome do seu idioma, mas não JSou Javascript.)
  • O nome completo no site oficial (ou repositório do GitHub) se o seu idioma de escolha não estiver disponível no TIO.
• Nenhum dos programas deve receber nenhuma entrada do usuário.
• Você pode usar comentários em qualquer idioma.
• Duas versões diferentes do mesmo idioma contam como idiomas diferentes.
  • Se isso for feito, o programa deverá emitir o número da versão principal e, se estiver executando em duas versões secundárias diferentes, também deverá reportar a versão secundária.
  • Você não deve usar funções de versão pré-construídas (isso inclui variáveis ​​que já foram avaliadas em tempo de execução).
• Dois sinalizadores de linha de comando diferentes no mesmo idioma também contam como idiomas diferentes, conforme este meta consenso , desde que os sinalizadores não incluam fragmentos de código (como -Dblahblah...em C).
  • Se isso for feito, o programa também deve exibir a bandeira usada.
• Dois erros são considerados diferentes, a menos que ambos sejam gerados pela mesma semântica (como "divisão por zero", "falha de segmentação" ou "índice fora do intervalo").
  • Se o tempo de execução de um idioma não sair após um erro, mas relatar o erro de alguma forma ao usuário, é um erro válido.
  • Se um idioma não discrimina as mensagens de erro, mas possui uma lista conhecida dos motivos que causam o erro, você deve especificar o motivo, não a mensagem de erro.
    Um exemplo é ><>, que possui apenas uma mensagem de erro something smells fishy..., mas a página wiki do esolangs possui uma lista de motivos de erro.
• O erro de sintaxe não é permitido, a menos que seja gerado por chamada eval()ou similar.
• Lançar algo manualmente (via throw(JS), raise(Python), die(Perl) ou similar) é permitido, mas todos eles são considerados como um tipo de erro.
• O erro por comando inválido em 2D ou golflangs também é permitido (e tratado como um tipo de erro).

Exemplos

Python e Ruby

• Python: This program errors out in Python :Ppara stdout, identificador indefinido
• Ruby: This program errors out in Ruby :Ppara stdout, depois indexe fora dos limites

C89 e C99

• C89: This program errors out in C 89 :Ppara stdout, depois divisão por zero
• C99: This program errors out in C 99 :Ppara stdout, falha de segmentação

Observe que o número da versão sempre deve ser separado do nome do idioma por um espaço.

Python 2.7.9 e Python 2.7.10

• Python 2.7.9: This program errors out in Python 2.7.9 :Ppara stdout e erro de sintaxe no eval
• Python 2.7.10: This program errors out in Python 2.7.10 :Ppara stdout, erro de chave no dict

Perl e Perl -n

• Perl: This program errors out in Perl :Ppara stdout, formato de hora inválido
• Perl -n: This program errors out in Perl -n :Ppara stdout, tente abrir um arquivo que não existe

Condição vencedora

Isso é código-golfe , então o código mais curto em bytes vence. Mas você sempre é incentivado a postar uma resposta que seja divertida ou interessante, mesmo que não seja muito curta.

Python 2 / Python 3 , 60 bytes

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

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

Python 2:

• /é divisão inteira, 3/2 obteve 1; int (3/2 * 2) é 2.
• print é uma declaração, então a primeira declaração é lida como print((...)*1)aqui *1significa repetir a string uma vez.
• A segunda instrução referenciou uma variável inexistente, que causou o erro.
• Experimente online!

Python 3:

• '/' é uma divisão numérica flutuante, 3/2 obteve 1,5; int (3/2 * 2) é 3.
• print é uma função, portanto, a primeira instrução é lida como (print(...))*1.
• função printretorna None; A multiplicação não funciona e None x int, portanto, informa "operando não suportado".
• Experimente online!

C e C ++, 114 101 bytes

-13 bytes graças a l4m2 !

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

Falha na segmentação em C ++, exceção de ponto flutuante em C.

autoé padronizado intem C, então (int).5se torna 0, então tentar dividir por isso é basicamente divisão por zero.

Em C ++ 1/dé 2, adicionando-o ao endereço ded e tentar alterar o valor desse endereço 'lança um segfault.

Experimente em C ++!
Experimente em 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>

Não tenho certeza se isso conta dois idiomas, mas é engraçado.

Java 8 e 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/**/;}}

Com base na minha resposta para os desafios 'abc' e 'cba' .

Experimente no Java 8 - resultando em ArrayIndexOutOfBoundsException: 1 .
Experimente em C - resultando na exceção de ponto flutuante: a divisão por zero é indefinida .

Explicação:

//\
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 você pode ver no código destacado em Java acima, a primeira linha é um comentário devido a //, e o código C é um comentário devido a /* ... */, resultando em:

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

Portanto, ele imprime em STDOUT e tenta acessar o segundo argumento do programa (quando não é fornecido), e produz o 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/**/;}}

Não tenho certeza de como habilitar corretamente o realce C, porque lang-cresulta no mesmo realce que Java. Mas //\comentaremos a próxima linha, que é o código Java, resultando em:

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

Portanto, ele imprime em STDOUT e, em seguida, fornece uma divisão por erro zero.

Java 8 e espaço em branco , 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]="";}}

Experimente no Java 8 - resultando em ArrayIndexOutOfBoundsException: 0 .
Experimente no espaço em branco - resultando em erro do usuário (Impossível executar o Infix Plus) .

Explicação:

Java 8:

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

Portanto, ele imprime em STDOUT e tenta acessar o primeiro argumento do programa (quando não é fornecido), e produz o ArrayIndexOutOfBoundsException .

Espaço em branco:

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

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Experimente esta versão destacada.

Espaço em branco é uma linguagem baseada em pilha que ignora tudo, exceto espaços, tabulações e novas linhas. Aqui está o mesmo programa no pseudo-có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

Irá ocorrer um erro assim que terminar de imprimir todos os valores e a pilha estiver vazia quando tentar fazer o Add ( TSSS), que requer dois itens na pilha.

Eu criei a constante 111com este programa Java , que também usei para desafios anteriores relacionados ao ASCII que fiz no Whitespace. Além disso, usei algumas cópias para os espaços para salvar bytes.

Uma coisa importante a ser observada é o truque que usei para colocar o programa Java na resposta Whitespace. Deixe-me começar explicando como um número é enviado no espaço em branco:

Sno início: ative a manipulação de pilha;
S: Empurre o que segue como Número;
Sou T: positivo ou negativo, respectivamente;
Alguns Se / ou T, seguidos por um N: Number as binary, where T=1and S=0.

Aqui estão alguns exemplos:

• Empurrando o valor 1 será SSSTN;
• Pressionando o valor -1 será SSTTN;
• Pressionando o valor 111 será SSSTTSTTTTN.
• Empurrando o valor 0 pode ser SSSSN, SSTSN, SSSN, SSTN, SSSSSSSSSSSSN, etc. (Quando você usa SSSN(ou SSTN), não temos para especificar a parte binária, porque é implicitamente 0 depois de termos declarado o seu sinal.)

Então, basta apenas SSSNempurrar o valor 0(usado para a letra oneste caso). Mas, para colocar o programa Java nesse programa Whitespace, eu precisava de um espaço adicional; portanto, os dois primeiros os são pressionados SSSN, mas o terceiro é pressionado SSSSN, para que tenhamos espaço suficiente para a frase do programa Java.

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

Teve que adicionar 2 bytes depois de perceber um erro de sintaxe não era permitido ....

Hexdump do .prgarquivo:

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

A visualização CBM BASIC , conforme listada no editor do 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

Atenção : É impossível inserir corretamente este programa no editor BASIC. Nem tente editar este programa no editor BASIC, pois ele trava. Ainda assim, é um programa BASIC executável;)

A exibição do código da 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

Demonstração online , digiterunpara executar como BASIC,sys 2049para executar como código de máquina,listpara mostrá-la interpretada como código BASIC.

Executando como BASIC produz um division by zero error in 1, executando como código de máquina umcan't continue error

Explicação:

Os dois primeiros bytes de um .prgarquivo são o endereço de carregamento em little endian, este é $0801(decimal 2049) aqui, que é o endereço inicial dos programas BASIC no C64. runinicia esse programa no intérprete BASIC, enquanto sys 2049é o comando para executar um programa de código de máquina no endereço 2049.

Como você pode ver, a primeira linha na visualização BASIC é um comment ( rem) contendo "lixo" e parte da cadeia de saída necessária. Este é o programa de código da máquina e alguns bytes de preenchimento. Você vê alguns comandos BASIC "aleatórios" lá porque os programas CBM-BASIC contêm os comandos "tokenizados" como valores de byte único, e alguns desses valores são iguais aos códigos de operação usados ​​no código da máquina. O código da máquina reutiliza a cadeia presente na segunda linha de código para sua saída.

Os dois primeiros bytes de uma linha de um programa básico são um ponteiro para a próxima linha, aqui $0850. Isso é escolhido com cuidado, porque 50 08também é uma instrução de ramificação 6502 pulando nos próximos 8 bytes quando o sinalizador de estouro não está definido - isso é usado para pular em algum lugar no meio dessa linha de "comentário" quando executado como código de máquina. Como 50é o opcode usado aqui, a segunda linha deve começar 0850para que o truque funcione. É por isso que você vê uma sequência de 5 20bytes (caracteres de espaço) para preencher. O código da máquina salta ativamente para a rotina de tratamento de erros da ROM para fornecer um erro "não pode continuar".

O código BASIC é bastante direto; como um segundo argumento para "imprimir", duas variáveis ​​não inicializadas (com um valor 0no CBM BASIC) são divididas, acionando o erro "divisão por zero".

> <> e Foo , 42 bytes

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

Experimente em> <>!

Experimente em Foo!

O Foo imprime tudo ", como está bem documentado, e tenta dividir por zero no final. Ignora o '><>'.

><>empurra o "Foo" para a pilha, mas aparece imediatamente usando p. Depois de imprimir tudo na pilha, #o<ela sai quando a pilha está vazia com a única mensagem de erro que ela conhece,something smells fishy...

C e Python, 126 116 bytes

-10 bytes graças a @Bubbler!

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

No Python, print () é None, portanto, tentar obter seu negativo não faz sentido; portanto, o Python gera um erro.

Em C printf () retorna um int, então dividi-lo por zero gera uma exceção de ponto flutuante.

Experimente em C!
Experimente em Python!

Attache + Wolfram Language (Mathematica) , 82 bytes

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

Experimente o Attache online! Experimente o Mathematica online!

Isso gira em torno do significado do operador = nos dois idiomas. No Attache, ele se compara à igualdade, mas no Mathematica, ele executa a atribuição de variáveis. :=faz atribuição de variável nos dois idiomas.

Agora, no Attache, Printretorna uma matriz de cadeias impressas, e a subtração não é possível com cadeias e números inteiros (ou seja, 0). Portanto, um erro de tipo é gerado. No Mathematica, Printretorna Null, e o Mathematica está subtraindo muito bem 0disso. Mas, jogamos manualmente esse nulo com Throw, dando um nocatcherro.

Python (2) e QB64 , 82 bytes

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

Para testar a versão Python, você pode experimentá-lo online! Para testar a versão QB64, você precisará fazer o download do QB64.

O que o Python vê

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

A primeira linha é apenas a expressão vazia 1(no-op) seguida de um comentário.

A segunda linha define sa sequência "QB64", mas a terceira linha a altera imediatamente para "Python". A quarta linha imprime a mensagem de acordo.

A quinta linha é outra expressão simples, mas gera um NameErrorpor causa do nome indefinido CLS.

O que o QB64 vê

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

A primeira linha, numerada 1#, define cada variável cujo nome começa com S(sem distinção entre maiúsculas e minúsculas) como uma variável de sequência. Isso significa que não precisamos usar s$, o que seria um erro de sintaxe no Python.

A segunda linha é definida scomo a sequência "QB64". 'inicia um comentário no QB64, para que a terceira linha não faça nada. A quarta linha imprime a mensagem de acordo.

A quinta linha tenta CLS(limpar a tela) com um argumento de -1. Mas desde que CLSsó aceita argumentos de 0, 1ou 2, isso produz o erro Illegal function call. O erro cria uma caixa de diálogo perguntando ao usuário se ele deseja continuar a execução ou abortar. Tecnicamente, isso significa que o erro não é fatal (nesse caso, você pode escolher "continuar a execução" e o programa simplesmente termina sem maiores problemas); mas o OP permitiu explicitamente idiomas que podem continuar após um erro; portanto, o comportamento do QB64 deve ser bom.

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

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

Isso faz uso do fato de que (...)há uma lista no Perl queprintf usará o elemento mais à esquerda e o fato de ser o operador de vírgula no JavaScript, que retornará o argumento mais à direita.

Causa erro de divisão por zero no Perl e no ReferenceError porque $ não está definido no JavaScript.

Experimente o Perl online!

Experimente o JavaScript online!

Oitava e MATLAB, 67 bytes

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

Experimente online!

Notas: O código supõe que o MATLAB está instalado sem caixas de ferramentas (ou que os nomes de qualquer caixa de ferramentas instalada não começam com as letras A a M).

Como funciona:

O código obtém os dados da versão para o intérprete e as caixas de ferramentas usando ver. A execução v(1).Nameextrai o nome do primeiro produto; isso retornará um OctaveouMATLAB assumindo que a nota acima seja verdadeira.

O programa exibirá a sequência necessária, completa com Octaveou MATLABconforme necessário.

Finalmente nós fazemos v(--pi).

No Octave, --é o operador de pré-decremento. Como tal, ele tenta pré-diminuir o que falha, pois a variável pinão existe ( pina verdade é função, não uma variável).

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

No MATLAB, o operador de pré-decréscimo não existe. Como tal, a afirmação é interpretada como v(-(-pi))sendo igual a justa v(pi). No entanto, pinão é um número inteiro, portanto, não pode ser usado para indexar na vmatriz, causando um erro.

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 bytes

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

Experimente online! (C ++ 14)

Experimente online! (C ++ 17)

Assume que <cstdio>declara printfno namespace global (além de std) e que o conjunto de caracteres de execução básica usa valores ASCII, que são verdadeiros usando g ++ no Linux.

O problema básico aqui é que o C ++ 17 eliminou os trigramas da linguagem.

No C ++ 14, "??/0"contém um trigrafo e é equivalente a "\0". Então *"??/0"é zero e cestá definido como zero. O número 4 é passado como argumento para printf, então a divisão por ccausa um comportamento indefinido. No Linux, isso acontece antes de *pentrar em cena, e o programa recebe umaSIGFPE .

No C ++ 17, "??/0"é exatamente o comprimento 4 que parece ser. Assim *"??/0"é '?'ou 63 e cestá definido como 3. O número 7 é passado como argumento para printf, e desta vez a divisão por cé válida. Como pé um membro do espaço para nome, ele é inicializado com zero no início do programa e possui um valor de ponteiro nulo, assim *pcomo um comportamento indefinido. No Linux, como o programa tenta modificar a memória no endereço zero, o programa obtém a SIGSEGV.

Perl 5 e Perl 6 , 55 bytes

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

Experimente o Perl 5 online! (Divisão ilegal por zero)

Experimente o Perl 6 online! (Não existe esse método)

O prefixo ~é a stringificação no Perl 6 e essencialmente um no-op no programa acima. No Perl 5, não é bit a bit, convertendo -1 em 0.

. é uma sintaxe de chamada de método no Perl 6 e concatenação no 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*/

Experimente online! (C (gcc))

Experimente online! (Stax) ou Executar e depurar! (Stax)

Segfault em C. Operação inválida no Stax. Eu amo como tudo o que não é um comentário é realmente usado no Stax.

C

É assim que C vê isso. A primeira linha é no-op. A segunda linha imprime a mensagem com printfe, em seguida, segfaults devido ao =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

O programa Stax termina sempre que ele tenta aparecer ou espiar da pilha vazia. Isso torna um pouco complicado e temos que preparar uma pilha que não esteja vazia. AA=~1;faz isso enquanto permanece uma declaração válida em 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 (**)

O que é realmente útil é ~: ele prepara uma pilha de entradas não vazia para que ;possa ser executada sem sair do programa. No entanto, os dois1 s na pilha principal também são usados ​​posteriormente.

A segunda linha começa com uma guia e inicia um comentário de linha no 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

A operação inválida está tentando executar uma /operação para uma sequência como o TOS (2º operando) e o número 1de (*) como o 1º operando, que é inválido.

Se os dois operandos forem trocados, seria uma operação válida no Stax.

Gelatina e M , 39 bytes

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

Experimente em geléia!

Experimente em M!

Ambos os idiomas se aplicam inversamente İ à 0que resulta em infpara Jelly e zoopara M. Eu não sei por quezoo representa o infinito em M. Pergunte Dennis.

A diferença importante é que o infinito de Jelly é igual a si mesmo, enquanto o infinito de M não é. Assim, a mônada "é igual a si mesma"=` produz 1em Jelly e 0em M. A partir daqui:

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

O erro de Jelly é EOFError: EOF when reading a line.

O erro de M é 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

Isso ocorre com um erro de divisão por zero no Foo e uma NumberFormatException no CJam.

Para CJam:

• Uma string literal (entre aspas) se empurra para a pilha. Os itens da pilha são impressos automaticamente sem separador quando o programa termina.
• /tenta dividir a sequência This program errors out in na substringFoo . Como a string não contém a substring, isso gera uma matriz singleton contendo a string original, exibida exatamente da mesma maneira.
• 'x é um caractere literal para x , impresso da mesma maneira que uma sequência de um caractere. Dessa forma, podemos enviar dados para o CJam que são ignorados pelo Foo (não descobri como fazer um loop não ser executado no Foo).
• Litenta converter a cadeia vazia em um número inteiro, que falha. Tudo da pilha é impresso.

Para Foo:

• Uma string literal (entre aspas) é impressa automaticamente.
• /tenta dividir a célula atual pelo elemento da pilha superior (que é implícito 0). Por alguma razão, erros de divisão por 0 não são fatais no Foo, portanto, isso apenas imprime a mensagem

  Only Chuck Norris can divide by zero.

  para STDERR e continua.
• Caracteres não reconhecidos ( 'C'J'a'me Li) são ignorados.

Python e 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")

Erros: 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 várias diferenças:

• <var>=<a>,<b>,... cria uma tupla em Python, mas em Lua ele cria uma lista de argumentos, da qual apenas o primeiro membro é retirado.
• #inicia um comentário em Python, mas é o operador de comprimento em Lua. Adereços extras para o Python por permitir que as tuplas terminem em vírgula.
• [[...]]é a sintaxe de cadeias multilinhas de Lua, o que significa que ele nem vê a função de impressão do Python; isso é necessário devido a Lua usar ..para concatenação de strings e não+ .
• Erros de Python depois de ver a, uma variável indefinida; Lua depois z=#print(x.."Lua :P"). Usar apenas #print(x.."Lua :P")para Lua não funciona, pois isso gera um erro antes que o código seja executado.

Edições:

• Não há necessidade de usar "".join em Python, -1 byte
• Faça xuma string nos dois idiomas e coloquePython uma sequência literal na função de impressão, -8 bytes
• O uso #[[]]é mais curto que #""e--[[]] -4 bytes
• Não há necessidade de usar #1como chave de tabela, -3 bytes
• Jo King fez isso , -9 bytes
• Tomando a duração do valor de retorno das print(x.."Lua :P")obras, aparentemente; -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]/**/;}}

Abusar o manuseio de escape diferente entre java e C # (escapamentos unicode são analisados ​​antes da análise de código em java e não em c #) como uma espécie de pré-processador, é o trabalho do \u0027 mágica, o resto são alguns "comentários de alternância"

Edit: Golfed off 8 bytes graças a um ponteiro de @KevinCruijssen

Editar: derp de regra corrigido

AutoHotKey / C #, 155 133 128 122 bytes

O destaque da sintaxe explica melhor do que eu poderia:

C # RuntimeBinderException: 'Não é possível chamar um tipo não delegado'

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

Erro de AutoHotkey : Uma exceção foi lançada.

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

Edições:

1. removeu uma var
2. -5 bytes graças ao leite

PHP 7+ / JavaScript, 90 89 bytes

Ele usa 2 idiomas com sintaxe muito semelhante, permitindo escrever esse código nos dois idiomas.

A separação do idioma é feita por uma propriedade não presente no JavaScript: o PHP considera [] (matriz vazia) um valor falso enquanto é verdadeiro no JavaScript (porque é um objeto e os objetos são sempre verdadeiros, mesmo new Boolean(false)).

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

Execução:

Incidirá sobre o seguinte trecho de código: ([]?console.log($X,'JavaScript'):printf($X,PHP))();.

A atribuição de string funciona da mesma maneira nos dois idiomas.

Este código usa o "operador ternário" ( Javascript , PHP ), que funciona basicamente da mesma maneira nos dois idiomas.

Javascript

Javascript executará o console.log($X,'JavaScript') peça, que retornará undefined.

Mais tarde, quando você tenta executar (...)() , recebe um Uncaught TypeError: (intermediate value)(intermediate value)(intermediate value) is not a function(no Google Chrome).

PHP

O PHP executará o printf($X,PHP) peça.

No PHP, a printffunção retorna o comprimento da saída .

O PHP tem uma funcionalidade interessante: ele pode executar funções cujo nome está armazenado em uma variável (ou, desde o PHP7, como resultado de uma expressão), o que evita um erro de sintaxe.

O PHP tentará executar a função cujo nome é o resultado da expressão []? ... :printf($X,PHP)(que é o número 33).
Mas essa funcionalidade interessante tem uma ressalva: só aceita strings (duh!).

Isso causa a Fatal error: Function name must be a string, porque 33é um int.

Obrigado a Shieru Asakoto por me salvar 1 byte!

Perl 5 e C, 95 bytes

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

//; é basicamente um NOP em perl e é um comentário em C.

Portanto, o programa C é efetivamente:

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

Que imprime a sequência necessária e tenta executar puts(32). Esse é um comportamento tecnicamente indefinido em C, mas causa uma falha de segmentação no TIO e em todos os sistemas aos quais tenho acesso.

O programa perl trata todo o programa C como uma string, usa o regex /T.*n /para corresponder This program errors out ine depois imprime isso e perl :P. diefaz com que o programa falhe com o erro Died at script_name line 2.

Se você não gostar disso como um erro, 1/0é do mesmo tamanho e trava com um Illegal division by zeroerro. Eu só gosto de diemais;)

Experimente online! (C)

Experimente online! (Perl)

VBScript, JScript, 72 bytes

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

O VBScript imprimirá "Erro de tempo de execução do Microsoft VBScript: incompatibilidade de tipo: 'y'" O
JScript imprimirá "Erro de tempo de execução do Microsoft JScript: 'y' está indefinido"

JavaScript e Python 3, 105 91 bytes

Erros NameError: name 'console' is not definedno Python 3

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

Experimente online!

... e por TypeError: console.log(...) is not a functionem JavaScript.

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

Experimente online!

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

Experimente online! (Java)

Experimente online! (JavaScript)

Saída em Java:

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

Saída em JavaScript (para stderr):

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

Isso aproveita a digitação fraca do JavaScript ( 1=='1') para detectar a linguagem, as mesmas palavras-chave em Java e JavaScript ( var, class) e os construtores de erro semelhantes ( new Error()) para criar o poliglota.

PowerShell v6 e PowerShell v2, 73 bytes

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

Experimente online!

Isso gerará um erro de análise na v2 porque -shlfoi introduzido na v3. O v3 + poderá alterar corretamente o valor antes de tentar dividi-lo por 0, gerando convenientemente um erro de divisão por zero. Ambas as versões têm o hashmap $ PSVersionTable que contém o PSVersioncampo

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

Não testado no Mac; basicamente, John Cook apontou (em seu blog ) que o POSIX não define gama; O Linux usa o log da função gama (log (gamma (1)) retornará 0, o que acionará uma exceção de ponto flutuante); O OSX usa a função gama "true" (que é oficialmente chamada de tgamma por POSIX); isso retorna 1 que atingirá a instrução abortar; Eu tentei fazer com que ele lançasse um erro de ponto flutuante diferente (por exemplo, sqrt (-1), mas estou esquecendo como fazer com que esse erro seja disparado vs apenas retornar zero)

Perl, Bash (78 bytes)

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

Saída em Perl:

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

Saída no Bash:

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

(Observe que o Bash está realmente exibindo o line 4erro, apesar do fato de a linha 3 não terminar com um avanço de linha ...)

C e ECPP, 112 bytes

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

• Experimente online! (C) Lança o erro 1,Hangup ,.
• Experimente online! (ECPP) Lança erro 4 Illegal instruction,.

C (gcc) e 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""]

Experimente online (С)! Experimente online (Haskell)!

O resultado é obtido entrelaçando os comentários, sendo a versão C essencialmente esta:

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

(A falha é obtida escrevendo antes do início da string).

A versão Haskell, por outro lado, reduz-se ao seguinte:

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

(A falha é alcançada seguindo uma lista vazia)