Produza um programa A de modo que executá-lo no idioma A produz o Programa B e executar o programa A no idioma B produz o programa C.

O programa B, quando executado no idioma B, produz o Programa A, e o programa B, no idioma A, produz o programa C.

O programa C, quando executado no idioma A ou no idioma B , imprime "Idioma errado!".

Program | Language | Result
--------|----------|----------
A       | A        | Program B
B       | B        | Program A
A       | B        | Program C
B       | A        | Program C
C       | A        | "Wrong language!" 
C       | B        | "Wrong language!" 

Sua resposta deve usar este modelo:

Idioma A / Idioma B, {a bytes} + {b bytes} = {total de bytes} bytes

Programa A:

a code

Programa B:

b code

Programa C:

c code 

Fonte:

# Language A/Language B, <a bytes> + <b bytes> = <total bytes> bytes

Program A:

    a code
Program B:

    b code
Program C:

    c code

• Nenhum desses programas deve receber contribuições.
• Versões diferentes do mesmo idioma contam como idiomas diferentes. (embora isso seja desencorajado porque leva a soluções chatas)
• Os idiomas A e B devem ser distintos.
• Você não deve ler seu próprio código-fonte de um arquivo. Os programas podem não estar vazios
• Aplicam-se brechas padrão.

Dicas

• C ++ e [Python / Bash / outras #linguagens comentadas] são boas combinações porque você pode definir macros que uma linguagem pode ignorar

Isso é código-golfe , então a menor soma do byte conta o Programa A e B vence.

Befunge-98 (PyFunge) / > <> , 123 + 123 = 266 250 246 bytes

"81!#.#vp00g>:#,_j+4<.=1l5v!o#!g00
g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# \!gff+k,@,k*8ba$$ #o#!a"

Experimente no Befunge-98! , Experimente em> <>!

"00g!#o!v5l1=.<4+j_,#:>g00pv#.#!18
g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# \!gff+k,@,k*8ba$$ #o#!a"

Experimente em> <>! , Experimente-o em Befunge-98!

"a0!#.pek,@f[>o<!egaugnal gnorW

Experimente no Befunge-98! Experimente em> <>!

Como funciona:

A segunda linha nos dois programas é idêntica e serve a mesma função para os dois idiomas. Quando inserido à esquerda a partir de <<<<, imprime a segunda linha inteira. Ao entrar à direita, imprima o programa C.

Quando a primeira linha é executada no idioma errado, ela entra na seção de produção do programa C. Caso contrário, imprime a linha superior para trás com "a parte da frente e entra na segunda linha de produção.

Primeira linha

"81!#.#vp00g>:#,_j+4<.=1l5v!o#!g00

><>:
" Wrapping string literal over the first line
 81!#.  Jumps the pointer to the Program C producer

Befunge-98:
" Wrapping string literal
 81!#.  Pushes 8,0 (! inverts number, # skips over .)
      #v Skip over the exit
        p00g Pops the excess 8,0 and space and gets the " from 0,0
            >:#,_ Classic print until stack is empty
       v         j+4< Skips back to the exit and goes to the second line

"00g!#o!v5l1=.<4+j_,#:>g00pv#.#!18

><>:
" Wrapping string literal
 00g!# Gets the " from 0,0
      o!v5l1=. Print until the stack is empty and jump to the second line

Befunge-98:

" Wrapping string literal
 00g Gets the " from 0,0
    !#o!v Skip the instruction o and go to Program C producer

Segunda linha:

g00<<<<<>0!#[f8+1!#.48*k'Wrong language!<o>[f@,kep.#!0a'00g!#o# $$00gff+k,@,k*9aa$$ #o#!a"

><>: Second line producer
g00<<<<< Get the " from cell 0,0
        ......      " Wrapping string literal over the stack
               #o#!a  Print newline and the stack and exit
Program C producer:
       >0!#[        Clear stack
            f8+1!#. Jump to cell 22,1
                   .....'...'   Push program C to the stack
                             00g Get " from cell 0,0
                                !#o# Print stack until empty

Befunge-98: Second line producer

g00<<<<< Get the " from cell 0,0
        ......              " Wrapping string literal
                       #o#!a  Skip over instruction o
                     $$       Pop the excess characters
                  90a Push a newline and 90
               @,k      Execute , instruction (print) 90+1 times, printing second line

Program C producer:
        >0!#[ Push 1 and skip [
             f8+1!#. Push 22, 0 and skip .
                    48*k'...' Execute ' instruction 32 times, pushing program C
                         ...'00g!#o# Push 0 and skip the instruction o
                                     \! Convert excess values to two 0s
                                       g Get " from cell 0,0
                                          ff+ Push 30
                                             k, Execute , 30+1 times, printing program C
                                               @ Exit program

Programa C

"a0!#.pek,@f[>o<!egaugnal gnorW

><>:
" Wrapping string literal
 a0!#. Jump to cell 10,0
           f[ Create a new stack with only the top 15 elements
             >o< Print stack

Befunge-98:
" Wrapping string literal
 a0!#. Push 10,1
      p Pop 10,1 and excess space
       ek,@ Push 14 and execute , 14+1 times and exit the program

JavaScript (ES6) / Python 3, 264 + 258 = 522 bytes

Programa A:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;print(c);'''
console.log(b,...[a,b,c].map(uneval))//'''

Programa B:

a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";c="1//2;alert=print\nalert('Wrong language!')";1//2;'''
print=_=>console.log(c)//'''
print(a%(a,b,c))

Programa C:

1//2;alert=print
alert('Wrong language!')

Provavelmente jogável ...

Explicação sobre JavaScript

Programa A:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;print(c);'''

// Print the Python program (b), replacing the "%s"s with the raw forms of a, b, and c:
console.log(b,...[a,b,c].map(uneval))//'''

Programa B:

// Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

// Ignore this line:
1//2;'''

// Define a function `print` which prints `c` (the "Wrong language!" program):
print=_=>console.log(c)//'''

// Call `print`, ignoring the argument (which is NaN):
print(a%(a,b,c))

Programa C:

// Ignore this line:
1//2;alert=print

// Alert "Wrong language!":
alert('Wrong language!')

Explicação em Python

Programa A:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Print `c` (the "Wrong language!" program):
1//2;print(c);

# Ignore this part:
'''
console.log(b,...[a,b,c].map(uneval))//'''

Programa B:

# Set a, b, and c to these strings:
a="a=%r;b=%r;c=%r;1//2;print(c);'''\nconsole.log(b,...[a,b,c].map(uneval))//'''";
b="a=%s;b=%s;c=%s;1//2;'''\nprint=_=>console.log(c)//'''\nprint(a%(a,b,c))";
c="1//2;alert=print\nalert('Wrong language!')";

# Ignore this part:
1//2;'''
print=_=>console.log(c)//'''

# Print the JS program (a), replacing the "%r"s with the raw forms of a, b, and c:
print(a%(a,b,c))

Programa C:

# Set `alert` to the function `print`:
1//2;alert=print

# Call this function on "Wrong language!":
alert('Wrong language!')

Python 3 + JavaScript (Rhino), 171 + 171 = 342 bytes

Programa A (gera o programa B em Python 3, programa C em JavaScript; observe a nova linha):

s="'";d='"';r=['print("s="+d+s+d+";d="+s+d+s+";r=["+s+r[1]+s+","+s+r[0]+s+"];eval(r[([11]+[0])[1]])")','print("print("+d+"Wrong language!"+d+")")'];eval(r[([11]+[0])[1]])

Programa B (gera o programa A em JavaScript, programa C em Python; observe a nova linha):

s="'";d='"';r=['print("print("+d+"Wrong language!"+d+")")','print("s="+d+s+d+";d="+s+d+s+";r=["+s+r[1]+s+","+s+r[0]+s+"];eval(r[([11]+[0])[1]])")'];eval(r[([11]+[0])[1]])

Programa C (gera "Idioma errado!" Em qualquer idioma; também possui uma nova linha à direita, que não conta na pontuação):

print("Wrong language!")

Observe que estou usando um dialeto incomum de JavaScript aqui. As pessoas normalmente usam implementações de navegador, mas elas têm problemas com a saída, fazendo isso de uma maneira estranha (usando alert). Estou usando o pacote Ubuntu, rhinoque é uma implementação JavaScript "offline" com um conjunto diferente de bibliotecas implementadas em um navegador típico (ele se destina como uma linguagem de script incorporável); isso é notável, pois fornece uma printdeclaração no mesmo estilo que, por exemplo, Python 3.

Este é um "verdadeiro poliglota" no sentido de que os dois idiomas estão executando os mesmos cálculos, na mesma ordem, dando a eles o mesmo significado. Ambos têm o mesmo AST (e é bastante trivial criar uma solução poliglota Python 3 + JavaScript via redução deste programa). Não há código específico para um idioma, o que me ajuda a diminuir o comprimento. Aliás, você precisa usar o Python 3 para poder usar ponto-e-vírgula para separar instruções (se você usou novas linhas, precisará escapar das novas linhas).

O programa começa definindo cadeias se dque contêm aspas simples e aspas duplas, respectivamente. Isso possibilita a saída de cotações sem precisar mencioná-las posteriormente no código-fonte, evitando problemas com escape (o que freqüentemente parece ser um problema com quines; a principal razão pela qual eu respondo a tantos problemas de quine no Underload é que suas cadeias se aninham) .

O coração do programa é a matriz rque contém o corpo principal dos dois programas usados ​​pelo desafio; um dos programas (o que vem primeiro no programa A e o segundo no programa B) é quase um quine que simplesmente gera o programa original por meio da concatenação de peças juntas (tiradas principalmente dele r, com algumas literais de seqüência de caracteres), e o outro programa de impressão C. Para fazer com que o programa não seja um quine verdadeiro (o que tornaria impossível detectar que estávamos executando no idioma errado), os elementos de rsão impressos em ordem inversa; r[0]no programa A está r[1]no programa B e vice-versa.

Finalmente, tudo o que é necessário é evalusar o elemento correto de r. Isso é feito usando a expressão ([11]+[0])[1]que produz um valor diferente no Python 3 e no JavaScript. Os dois idiomas o analisam de maneira idêntica, mas têm idéias diferentes sobre o que a adição faz nas listas:

• Quando Python 3 adiciona [11]a [0], torna-se [11, 0](concatenando as listas), e em seguida, tomando o segundo elemento da lista ( [1]) nos dá o inteiro 0.

• Quando JavaScript acrescenta [11]que [0], ele é "110"(concatenando as representações de seqüência de listas), e em seguida, tomando o segundo personagem da string ( [1]) dá-nos a corda "1", que JavaScript é bastante feliz em usar como um índice em uma lista.

Portanto, o Python 3 executa o primeiro elemento de rambos os programas (produzindo quase tudo ao executar o programa A e imprimindo o programa C ao executar o programa B); O JavaScript executa o segundo elemento e, portanto, trata os programas A e B da maneira inversa.

Aliás, se você executar o programa A no Ruby, ele imprimirá o programa B, exceto sem uma nova linha à direita. Se você executar o programa B no Ruby, ele imprimirá o programa C, exceto sem uma nova linha à direita. Em outras palavras, essa solução quase funciona com um conjunto diferente de linguagens, trocando Python 3 por Ruby (a única razão pela qual não excluo a nova linha do programa B para obter uma pontuação de 341 é que a inconsistência da nova linha no programa C desqualificaria o envio).

(Eu estava trabalhando em um "verdadeiro poliglota" como esse por um motivo diferente, que eu coloquei agora como um desafio, e percebi que as técnicas poderiam ser adaptadas a esse também.)

C / Python, 733 bytes + 733 bytes = 1466 bytes

Programa A:

#define int char*
int
a1="#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}";
int
a2="print(c%(13,34,34))";
int
b1="#define print(X) main(){printf(c,13,34,34);};";
int
b2="print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))";
int
c="#define print(a) main(){puts(a);}%cprint(%cWrong language!%c)";
int
d="#define int char*%cint%ca1=%c%s%c;%cint%ca2=%c%s%c;%cint%cb1=%c%s%c;%cint%cb2=%c%s%c;%cint%cc=%c%s%c;%cint%cd=%c%s%c;%c%s%c%s";
#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}
print(c%(13,34,34))

Programa B:

#define int char*
int
a1="#define print(X) main(){printf(d,13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,b1,13,b2);}";
int
a2="print(c%(13,34,34))";
int
b1="#define print(X) main(){printf(c,13,34,34);};";
int
b2="print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))";
int
c="#define print(a) main(){puts(a);}%cprint(%cWrong language!%c)";
int
d="#define int char*%cint%ca1=%c%s%c;%cint%ca2=%c%s%c;%cint%cb1=%c%s%c;%cint%cb2=%c%s%c;%cint%cc=%c%s%c;%cint%cd=%c%s%c;%c%s%c%s";
#define print(X) main(){printf(c,13,34,34);};
print(d%(13,13,34,a1,34,13,13,34,a2,34,13,13,34,b1,34,13,13,34,b2,34,13,13,34,c,34,13,13,34,d,34,13,a1,13,a2))

Programa C:

#define print(a) main(){puts(a);}
print("Wrong language!")

Eu usei sua dica de usar C / C ++ com Python. Não é muito conciso, mas ainda assim qualifico, suponho.

Python 2 / Retina, 550 + 645 = 1373 1254 1221 1195 bytes

Não tenho muita certeza se as peças unichre replacepodem ser mais jogadas de golfe. Tentei usar o Python 3, mas muito se perdeu ao adicionar parênteses e manipulá-los. Eu tentei configurar R=unicode.replacee usar isso, mas a saída fica confusa.

Observe que o Retina possui uma nova linha à direita em sua saída por padrão, e isso não está incluído nos programas. Se alguém disser que preciso removê-lo, isso pode ser feito trivialmente. Além disso, o código Python funciona em repl.it, mas não é garantido que funcione no Ideone.com.

Observe também que as novas linhas iniciais e finais são significativas no código abaixo.

Programa A (Python 2): 638 587 566 550 bytes (UTF-8)

Python 2 , Retina

U=unichr;s=U(39)*3;_=u'''\n#U=unichr;s=U(39)*3;_=u%s.replace(U(9),U(96));print _%%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|¶#·print"Wrong language!"·#?.*t|"·¶#{2}|^.¶\n#1 #\n\n#T ²-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''.replace(U(9),U(96));print _%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Programa B (retina): 735 667 655 645 bytes (ISO 8859-1)

Retina , Python 2

#U=unichr;s=U(39)*3;_=u'''\n#U=unichr;s=U(39)*3;_=u%s.replace(U(9),U(96));print _%%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|·#¸print"Wrong language!"¸#?.*t|"¸·#{2}|^.·\n#1   #\n\n#T ³-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''.replace(U(9),U(96));print _%(s+_+s).replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179)).replace(U(183),U(184)).replace(U(182),U(183))#|¶#·print"Wrong language!"·#?.*t|"·¶#{2}|^.¶
#1`#

#T`²-¹`_o`[^¹]
n=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n

Programa C:

Python 2 , Retina

Na verdade, isso pode ser mais curto usando em #!`W.*!vez das duas últimas linhas, mas isso torna A e B mais longos, porque ter `uma linha onde não havia um significa que preciso lidar com isso de maneira diferente (porque o primeiro backtick de uma linha na Retina é um delimitador de configuração).

print"Wrong language!"
#?.*t|"

Explicação:

Programa C:

                        # Retina: replace nothing with the Python code string
print"Wrong language!"  # >> code is executed if run in Python
#?.*t|"                 # Comment w/ '?' for Retina to skip, then replace up to the 't',
                        #    as well as any quotation marks, with nothing

Escrevi o Programa C primeiro durante minha primeira tentativa e o mantive praticamente o mesmo. No Python, ele imprime a string e ignora o comentário. Na Retina, ele não substitui nada print"Wrong language!"e remove as peças ao redor Wrong language!.

Para entender melhor os programas complexos, vejamos as versões simplificadas:

Programa A (simplificado):

print"\n#PYTHON\n#1`#\n\n#T`²-¹`_o`[^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n"#|
#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Quando comecei do zero, usei o PYTHONbit como um espaço reservado para o código que deveria imprimir o Programa A. Essa versão mais simples facilitou a explicação de como o Programa B e o Programa C seriam impressos.

O printe tudo dentro é o que imprime o Programa B, mas primeiro vamos ver como o Programa C é impresso, porque isso é simples. Após o print"..."é #|. Esse truque salvou MUITAS dificuldades que experimentei na minha primeira tentativa. Isso permite que o Retina não substitua nada pela 2ª linha, que será o Programa C, exceto que há um #na frente. As duas últimas linhas removem isso primeiro #. Eu costumava #{2}impedir o estágio de remover todas as ocorrências de #. Não posso usar #1`#como usei no Programa B, porque causa problemas para ter esse backtick na primeira linha do Programa A.

O que me leva à minha próxima tarefa, imprimir o Programa B. Você pode ter notado outra diferença em relação ao código real. Não existem backticks no código real, pois os substituí por abas. Eu tive que substituir um caractere, porque qualquer backtick tornaria o código anterior uma string de configuração no Retina, fazendo com que a sintaxe fosse inválida. Eu escolhi as guias porque elas são visíveis e o ponto do código é um único dígito ( 9). O código imprime o Programa B, como mostrado na versão simplificada abaixo.

Programa B:

#PYTHON
#1`#

#T`²-¹`_o`[^¹]
n=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n

As duas primeiras linhas não substituirão nada pelo código Python, mas por um #na frente e alguns caracteres ligeiramente diferentes. Esta parte é omitida para maior clareza. A próxima etapa remove isso primeiro #. Então, eu uso um estágio Transliteration (T) #T`²-¹`_o`[^¹]para desfazer algumas das replaceoperações vistas no Programa A. completo. Usar esse estágio é uma maneira de produzir um pilcrow literal ¶em Retina, que de outra forma seria impossível.¹ Ele substitui ·por ¶e ³com ². Ocorrências de ¹permanecerão as mesmas devido ao fato de serem ignoradas [^¹].

Programa A:

Novas linhas e guias foram adicionadas para facilitar a leitura.

U=unichr;s=U(39)*3;

_=u'''
    \n#U=unichr;s=U(39)*3;

    _=u%s.replace(U(9),U(96));

    print _%%(s+_+s)
    .replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179))
    .replace(U(183),U(184)).replace(U(182),U(183))#|

    ¶#·print"Wrong language!"·#?.*t|"·
    ¶#{2}|^.
    ¶

    \n#1    #\n\n#T ²-¹ _o  [^¹]\nn=chr(10);print n+n.join(['print"Wrong language!"','#?.*t|"'])+n\n'''

.replace(U(9),U(96));

print _%(s+_+s)
.replace(U(10),U(92)+'n').replace(U(96),U(9)).replace(U(178),U(179))
.replace(U(183),U(184)).replace(U(182),U(183))#|

#¶print"Wrong language!"¶#?.*t|"¶
#{2}|^.

Isso segue a estrutura geral do seguinte quine Python:

_='_=%r;print _%%_';print _%_

Quando você adiciona coisas antes ou depois, também precisa colocá-las na string.

U=unichr;_='U=unichr;_=%r;print(_%%_).replace('','')';print(_%_).replace('','')

Eu queria usar uma sequência de aspas triplas para facilitar a inclusão de aspas (evitando o uso de barras invertidas). s=U(39)*3;é a string '''. Também usei , em %svez de %r, para evitar problemas com novas linhas ou outros caracteres sendo escapados com barras invertidas.

U=unichr;s=U(39)*3;_='''U=unichr;s=U(39)*3;_=%s;print(s+_%%_+s).replace('','')''';print(s+_%_+s).replace('','')

Então agora, as substituições. A primeira substituição .replace(U(9),U(96));existe para substituir as guias pelos backticks que vemos no Programa B. Essa substituição é feita antes da formatação da string, porque as guias precisam permanecer como guias no Programa A. As outras substituições são simplesmente para evitar o uso de certos caracteres no segundo linha do Programa B:

.replace(U(10),U(92)+'n')   # Replace newlines with a backslash and 'n', for B to print A.
.replace(U(96),U(9))        # Replace backticks with tabs for the first part of B.
.replace(U(178),U(179))     # Replace '²' with '³', which will be undone with B's T stage
.replace(U(183),U(184))     # Replace '·' with '¸', which will be undone with B's T stage
.replace(U(182),U(183))     # Replace '¶' with '·', which will be undone with B's T stage

Essas três últimas substituições antecipam o estágio de Transliteração no Programa B, para impedir que esses caracteres sejam removidos ou transliterados quando não deveriam.

A única outra parte do código é o código do Programa B, que é essencialmente copiado caractere por caractere, exceto pelas alterações devido às substituições.

¹ Obrigado a Martin por sua dica sobre como gerar um literal ¶no Retina. Isso tornou tudo muito mais fácil.

Befunge / Python, 381 + 485 259 + 345 229 + 304 = 533 bytes

Programa A: Experimente no Befunge | Experimente em Python

#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''

Programa B: Experimente no Python | Experimente em Befunge

#>55+"]:5+5+["50g"!egaugnal gnorW"50g"'<:#>!#,_@<'tnirp">:#,_@
print """#>21g::35*:*::":"%\>:#$":"%#\ \#%":"/#::$#-g#1\_#+\#5:#5_v
#v"50g"g12"'<:#>!#,_@<'tnirp"g12">:#,_@"+55"print "::g12$<
#>21g"Wrong language!"21g"g05"21g"[+5+5:]"21g"+55>#">:#,_@
print'''print'<@_,#!>#:<'"Wrong language!"[+5+5:]'''"""

Programa C: Experimente no Befunge | Experimente em Python

print'<@_,#!>#:<'"Wrong language!"[+5+5:]

Explicação

Programa C: Isso se baseia no fato de que o Befunge-93 ignora instruções não suportadas; portanto, enquanto o pzero inofensivamente escreve um zero em 0; 0, o restante printé ignorado até a <instrução que inverte a direção. Em seguida, da direita para a esquerda, ele +5+5pressiona 10 (avanço de linha) na pilha, seguido pela sequência de mensagens e, em seguida, uma sequência de saída padrão é executada para gravar a sequência. No Python, está apenas imprimindo duas literais de seqüência de caracteres que são concatenadas juntas, mas a primeira (contendo o código Befunge) é cortada pela referência da matriz no final ( [+5+5:]).

Programa B: A primeira linha é uma sequência Befunge bastante básica para imprimir o Programa C. A única coisa interessante é a maneira como ele gera caracteres de citação usando 50g(ou seja, lendo o caracter da memória), que é mais eficiente do que calcular o código ASCII. A #>(uma ponte sobre a instrução de direção) é essencialmente um nop que impede que o código seja visto pelo Python, pois #é o caractere de comentário do Python. A interpretação Python começa na linha dois e está simplesmente imprimindo uma sequência de múltiplas linhas contendo o código fonte do Programa A.

Programa A: No Python, as três primeiras linhas são novamente ignoradas porque começam com #, enquanto a última linha simplesmente imprime o Programa C. O código Befunge serpenteia para frente e para trás nas três primeiras linhas, construindo a fonte do Programa B na pilha Em ordem inversa. Começa com três aspas, depois uma sequência que faz uma cópia da fonte do Programa A e, finalmente, o que é essencialmente uma string codificada com a abertura print """e a primeira linha do código Befunge. É apenas uma questão de escrevê-lo com uma sequência de saída padrão.

Alguns pontos de discórdia:

1. Foi-me dito que um quine usando o gcomando não é considerado um quine adequado no que diz respeito a esta comunidade. Não tenho certeza se essa regra também se aplicaria a esse desafio, mas, nesse caso, essa resposta também pode não ser considerada uma solução adequada.

2. Embora eu tenha dito que o Befunge-93 ignora instruções não suportadas, isso não está tecnicamente definido na especificação, e você precisará usar a -qopção de linha de comando (silenciosa) no interpretador de referência para evitar avisos no Programa C. A maioria dos outros intérpretes fique bem, porém, mas alguns dos mais esquisitos podem potencialmente falhar. Observe também que o Befunge-98 reflete em instruções não suportadas; portanto, um intérprete 98 fará um loop indefinidamente.

Perl / JavaScript, 176 bytes + 176 bytes = 352 bytes

Não pense que posso compartilhar 52 bytes do mecanismo subjacente da recompensa, mas gostei de criar isso. Eu acho que o que eu produzi atende aos critérios ...

Programa A:

$P=1;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Programa B:

$P=2;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Programa C:

$P=0;$_='$L=eval("printf=console.log;J=``;q=_=>_+J;2")||1;$P?printf(q`$P=%s;$_=%s%s%s;eval($_)`,$P=$P==$L?J?2:1:0,$q=J?h^O:atob("Jw"),$_,$q):printf("Wrong language!")';eval($_)

Explicação

Usa minha poliquina Perl / JavaScript como base, mas define uma variável adicional $Pque controla qual programa gerar. Usa a verificação que +[]é verdadeira no Perl, mas falsa no JavaScript.