Produzca un programa A de tal manera que ejecutarlo en el lenguaje A produzca el Programa B, y ejecutar el programa A en el lenguaje B produzca el programa C.

El programa B, cuando se ejecuta en el lenguaje B, produce el programa A, y la ejecución del programa B en el lenguaje A produce el programa C.

El programa C, cuando se ejecuta en el idioma A o el idioma B , imprime "¡Idioma incorrecto!".

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

Su respuesta debe usar esta plantilla:

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

Programa A

a code

Programa B:

b code

Programa C:

c code 

Fuente:

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

Program A:

    a code
Program B:

    b code
Program C:

    c code

• Ninguno de estos programas debe recibir aportes.
• Las diferentes versiones del mismo idioma cuentan como idiomas diferentes. (aunque esto se desaconseja porque conduce a soluciones aburridas)
• Los idiomas A y B deben ser distintos.
• No debe leer su propio código fuente de un archivo. Los programas pueden no estar vacíos
• Se aplican lagunas estándar.

Consejos

• C ++ y [Python / Bash / otros #lenguajes comentados] son ​​buenos combos porque puedes definir macros que un idioma puede ignorar

Este es el código de golf , por lo que la suma más pequeña de los bytes cuenta el Programa A y B gana.

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"

¡Pruébalo en Befunge-98! ¡ Pruébalo en> <>!

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

Pruébalo en> <>! ¡ Pruébalo en Befunge-98!

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

¡Pruébalo en Befunge-98! Pruébalo en> <>!

Cómo funciona:

La segunda línea en ambos programas es idéntica y cumple la misma función para ambos idiomas. Cuando se ingresa hacia la izquierda desde <<<<, imprime toda la segunda línea. Al ingresar a la derecha de esos, imprima el programa C.

Cuando la primera línea se ejecuta en el idioma incorrecto, ingresa a través de la sección de producción del programa C. De lo contrario, imprime la línea superior hacia atrás con "el frente y entra en la sección de producción de la segunda línea.

Primera linea

"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 linea:

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

Probablemente golfable ...

Explicación de 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!')

Explicación de 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 (genera el programa B en Python 3, el programa C en JavaScript; tenga en cuenta la nueva línea final):

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 (genera el programa A en JavaScript, el programa C en Python; tenga en cuenta la nueva línea final):

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 (genera "¡Idioma incorrecto!" En cualquier idioma; también tiene una nueva línea final, que no cuenta en el puntaje):

print("Wrong language!")

Tenga en cuenta que estoy usando un dialecto inusual de JavaScript aquí. Las personas normalmente usan implementaciones de navegador, pero tienen problemas con la salida, haciéndolo de una manera extraña (usando alert). Estoy usando el paquete de Ubuntu, rhinoque es una implementación de JavaScript "fuera de línea" con un conjunto diferente de bibliotecas implementadas en un navegador típico (está pensado como un lenguaje de secuencias de comandos incrustable); Esto es notable porque proporciona una printdeclaración en el mismo estilo que, por ejemplo, Python 3.

Este es un "verdadero políglota" en el sentido de que ambos idiomas ejecutan los mismos cálculos, en el mismo orden, dándoles el mismo significado. Ambos tienen el mismo AST (y es bastante trivial crear una quine poliglota Python 3 + JavaScript mediante la reducción de este programa). No hay código específico para un idioma, lo que me ayuda a reducir la longitud. Por cierto, debe usar Python 3 para que pueda usar punto y coma para separar las declaraciones (si usara nuevas líneas, tendría que escapar de las nuevas líneas).

El programa comienza definiendo cadenas sy dque contienen una comilla simple y una comilla doble respectivamente. Esto permite generar cotizaciones sin tener que mencionarlas más adelante en el código fuente, evitando problemas con el escape (que con frecuencia parece ser un problema con quines; la razón principal por la que respondo tantos problemas de quine en Underload es que sus cadenas anidan) .

El corazón del programa es la matriz rque contiene el cuerpo principal de los dos programas utilizados por el desafío; uno de los programas (el primero en el programa A y el segundo en el programa B) es casi un quine que simplemente genera el programa original mediante la concatenación de piezas (tomadas principalmente de rsí mismo, con unos pocos literales de cadena), y el otros imprime el programa C. Para que el programa no sea una quine verdadera (lo que haría imposible detectar que estábamos ejecutando en el idioma incorrecto), los elementos de rse imprimen en orden inverso; r[0]en el programa A está r[1]en el programa B, y viceversa.

Finalmente, todo lo que es necesario es determinar evalel elemento correcto de r. Esto se logra utilizando la expresión ([11]+[0])[1]que produce un valor diferente en Python 3 y en JavaScript. Ambos idiomas lo analizan de manera idéntica, pero tienen ideas diferentes sobre lo que hace la adición a las listas:

• Cuando Python 3 añade [11]a [0], se pone [11, 0](la concatenación de las listas), y luego tomando el segundo elemento de la lista ( [1]) nos da el número entero 0.

• Cuando JavaScript añade [11]a [0], se pone "110"(la concatenación de las representaciones de cadena de las listas), y después de tomar el segundo carácter de la cadena ( [1]) nos da la cadena "1", que JavaScript está muy feliz de usar como un índice en una lista.

Por lo tanto, Python 3 ejecuta el primer elemento de rambos programas (produce casi una quine cuando ejecuta el programa A e imprime el programa C cuando ejecuta el programa B); JavaScript ejecuta el segundo elemento y, por lo tanto, trata el programa A y el programa B al revés.

Por cierto, si ejecuta el programa A en Ruby, imprimirá el programa B, excepto sin una nueva línea final. Si ejecuta el programa B en Ruby, imprimirá el programa C, excepto sin una nueva línea final. En otras palabras, esta solución casi funciona con un conjunto diferente de idiomas, intercambiando Python 3 por Ruby (la única razón por la que no solo elimino la nueva línea del programa B para obtener una puntuación de 341 es que la inconsistencia de nueva línea en el programa C descalificaría la presentación).

(Estaba trabajando en un "verdadero políglota" como este por una razón diferente, que ahora publiqué como un desafío, y me di cuenta de que las técnicas también podrían adaptarse a este).

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

Usé tu pista de usar C / C ++ con Python. No muy conciso, pero aún calificando, supongo.

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

No estoy muy seguro de si las partes unichry replacese pueden jugar más. Intenté usar Python 3, pero se pierde mucho al agregar paréntesis y manejarlos. Intenté configurar R=unicode.replacey usar eso, pero la salida se desordenó.

Tenga en cuenta que Retina tiene una nueva línea final en su salida de forma predeterminada, y esto es no incluido en los programas. Si alguien dice que necesito eliminarlo, eso se puede hacer de manera trivial. Además, el código Python funciona en repl.it, pero no se garantiza que funcione en Ideone.com.

También tenga en cuenta que las nuevas líneas iniciales y finales son importantes en el código a continuación.

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

Pitón 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:

Pitón 2 , Retina

En realidad, esto puede hacerse más corto usando en #!`W.*!lugar de las dos últimas líneas, pero esto hace que A y B sean más largos, porque tener `una línea donde no había una significa que tengo que manejarlo de manera diferente (porque el primer retroceso en una línea en Retina es un delimitador de configuración).

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

Explicación:

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

Escribí el Programa C primero durante mi primer intento y lo mantuve prácticamente igual. En Python, imprime la cadena e ignora el comentario. En Retina, no reemplaza nada con print"Wrong language!"y luego elimina las partes alrededor Wrong language!.

Para comprender mejor los programas complejos, veamos versiones 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}|^.

Cuando comencé de cero, usé el PYTHON bit como marcador de posición para el código que debería imprimir el Programa A. Esta versión más simple hizo que fuera más fácil explicar cómo se imprimirían tanto el Programa B como el Programa C.

El printy todo lo que hay dentro es lo que imprime el Programa B, pero primero, veamos cómo se imprime el Programa C, porque eso es simple. Después del print"..."es #|. Este truco salvó MUCHAS dificultades que experimenté en mi primer intento. Esto permite que Retina no reemplace nada con la segunda línea, que será el Programa C, excepto que hay un #frente. Las últimas 2 líneas eliminan eso primero #. Solía #{2}evitar que la etapa eliminara todas las ocurrencias de #. No puedo usarlo #1`#como lo hice en el Programa B, porque causa problemas al tener ese backtick en la primera línea del Programa A.

Lo que me lleva a mi siguiente tarea, imprimir el Programa B. Es posible que haya notado otra diferencia con respecto al código real. No hay backticks en el código real, ya que los reemplacé con pestañas. Tuve que sustituir un carácter, porque cualquier retroceso haría que el código anterior fuera una cadena de configuración en Retina, lo que haría que la sintaxis no sea válida. Elegí pestañas porque son visibles y el punto de código es un solo dígito (9 ). El código imprime el Programa B como se muestra en la versión simplificada a continuación.

Programa B:

#PYTHON
#1`#

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

Las dos primeras líneas no reemplazarán nada con el código de Python, sino con un #frente y algunos caracteres ligeramente diferentes. Esta parte se omite para mayor claridad. La siguiente etapa elimina eso primero #. Luego, utilizo una etapa de Transliteración (T) #T`²-¹`_o`[^¹]para deshacer algunas de las replaceoperaciones que se ven en el Programa completo A. El uso de esta etapa es una forma de generar un pilcrow literal ¶en Retina, que de otro modo podría ser imposible. Reemplaza ·con ¶, y ³con ². Las ocurrencias de ¹permanecerán igual debido a que se ignoran con [^¹].

Programa A

Se han agregado nuevas líneas y pestañas para facilitar la lectura.

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}|^.

Esto sigue la estructura general de la siguiente quine de Python:

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

Cuando agrega cosas antes o después, también debe colocarlas en la cadena.

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

Quería usar una cadena entre comillas triples para facilitar la inclusión de comillas (evitando el uso de barras invertidas). s=U(39)*3;es la cadena '''. También usé en %slugar de %r, para evitar algunos problemas con las líneas nuevas u otros caracteres que se escapan con barras diagonales inversas.

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

Así que ahora, los reemplazos. El primer reemplazo .replace(U(9),U(96));está ahí para reemplazar las pestañas con los backticks que vemos en el Programa B. Este reemplazo se realiza antes del formateo de cadenas, porque las pestañas deben permanecer en el Programa A. Las otras reemplazos son simplemente para evitar el uso de ciertos caracteres en el segundo línea del 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

Estos últimos tres reemplazos anticipan la etapa de Transliteración en el Programa B, para evitar que esos caracteres se eliminen o se transcriban cuando no deberían.

La única otra parte del código es el código del Programa B que se copia esencialmente carácter por carácter, excepto por los cambios debidos a los reemplazos.

¹ Gracias a Martin por su consejo sobre cómo generar un literal ¶en Retina. Hizo todo mucho más fácil.

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

Programa A: Prueba en Befunge | Probar en 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: Probar en Python | Probar en 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: Prueba en Befunge | Probar en Python

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

Explicación

Programa C: Esto se basa en el hecho de que Befunge-93 ignora las instrucciones no compatibles, por lo tanto, mientras pescriben inofensivamente un cero en 0; 0, el resto printse ignora hasta la <instrucción que invierte la dirección. Luego, fluyendo de derecha a izquierda, +5+5empuja un 10 (salto de línea) a la pila seguido de la cadena del mensaje, y luego se ejecuta una secuencia de salida estándar para escribir la cadena. En Python solo está imprimiendo dos literales de cadena que se concatenan juntos, pero el primero (que contiene el código Befunge) se divide en la referencia de matriz al final ( [+5+5:]).

Programa B: La primera línea es una secuencia de Befunge bastante básica para imprimir el Programa C. Lo único interesante es la forma en que genera caracteres de comillas usando 50g(es decir, leyendo el carácter de la memoria) que es más eficiente que calcular el código ASCII. El #>(un puente sobre la instrucción de dirección) es esencialmente un nop que impide que Python vea el código, ya que #es el carácter de comentario de Python. La interpretación de Python comienza en la línea dos y simplemente imprime una cadena multilínea que contiene el código fuente del Programa A.

Programa A: en Python, las primeras tres líneas se ignoran nuevamente porque comienzan #, mientras que la última línea simplemente imprime el Programa C. El código de Befunge avanza y retrocede a través de las primeras tres líneas, construyendo la fuente del Programa B en la pila en orden inverso. Comienza con tres comillas, luego una secuencia que hace una copia de la fuente del Programa A, y finalmente lo que es esencialmente una cadena codificada con la apertura print """y la primera línea del código Befunge. Es solo cuestión de escribirlo con una secuencia de salida estándar.

Algunos puntos de contención:

1. Me han dicho que una quine que usa el gcomando no se considera una quine adecuada en lo que respecta a esta comunidad. No estoy seguro de si esa regla también se aplicaría a este desafío, pero si es así, esta respuesta tampoco podría considerarse una solución adecuada.

2. Si bien he dicho que Befunge-93 ignora las instrucciones no compatibles, eso no está técnicamente definido en la especificación, y necesitará usar la -qopción de línea de comando (silenciosa) en el intérprete de referencia para evitar advertencias en el Programa C. La mayoría de los otros intérpretes lo harán sin embargo, estará bien, pero algunos de los más descarados podrían colapsar. También tenga en cuenta que Befunge-98 se refleja en instrucciones no compatibles, por lo que un intérprete 98 solo se repetirá indefinidamente.

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

No creo que pueda compartir 52 bytes del mecanismo subyacente para la recompensa, pero disfruté construyendo esto. Creo que lo que he producido cumple los criterios ...

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($_)

Explicación

Utiliza mi poliquina Perl / JavaScript como base, pero establece una variable adicional $Pque controla qué programa generar. Utiliza el control que +[]es verdadero en Perl, pero falso en JavaScript.