El programa A emite el código del programa B cuando se ejecuta, y B emite la fuente de A.

Requisitos:

• Solo un idioma en ambos programas
• Los programas son diferentes. Un programa que se genera solo no califica.
• Ambos programas no están vacíos o tienen al menos 1 byte de longitud. Las nuevas líneas finales tanto en la fuente como en la salida se ignoran
• stdin está cerrado. No lea nada (por lo que no puede leer la fuente y manipularla). La salida va a stdout.
  Editar: stdin está conectado a /dev/null. Puede pedir que se cierre si se aclara.
• No use randomfunciones.

Adicional:

• Dar explicaciones si es posible

La puntuación es la longitud total . La nueva línea final no cuenta si no afecta el programa.

CJam , 13 + 13 = 26 bytes

{sYZe\"_~"}_~

Pruébalo en línea!

Salidas

{sZYe\"_~"}_~

Explicación

{       e# Standard quine framework, leaves a copy of the block on the stack
        e# for the block itself to process.
  s     e# Stringify the block.
  YZe\  e# Swap the characters at indices 2 and 3, which are Y and Z themselves.
  "_~"  e# Push the "_~" to complete the quine.
}_~

Como e\es conmutativo en su segundo y tercer operando, el otro programa hace exactamente lo mismo, intercambiando Zy Yvolviendo a su orden original.

CJam ,11 + 13 = 24 11 + 12 = 23 bytes

"N^_p"
N^_p

Pruébalo en línea!

Salidas:

"N^_p
"
N^_p

La salida tiene 13 bytes, pero:

La nueva línea final no cuenta si no afecta el programa.

Así que cambié el espacio a una nueva línea para aprovechar eso.

Se basa en la quine adecuada más corta de CJam:

"_p"
_p

Y N^consiste en xor la cadena con una nueva línea, que agrega una nueva línea si no hay una nueva línea, y elimínela si la hay, para una cadena en la que cada carácter es único.

Creo que he visto ese quine en la pregunta quine, pero no pude encontrarlo.

RProgN 2 , 3 + 3 = 6 bytes

Primer programa:

0
1

Pruébalo en línea!

Segundo programa:

1
0

Pruébalo en línea!

-2 gracias a Martin Ender .

C, 95 + 95 = 190 bytes

¡Gracias a @immibis por guardar 16 * 2 bytes!

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

Pruébalo en línea!

Salidas:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=0^1;printf(s,34,s,34,i);}

Pruébalo en línea!

Qué salidas:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

Javascript, 67 + 67 = 134 bytes

1er programa:

alert(eval(c="`alert(eval(c=${JSON.stringify(c)},n=${+!n}))`",n=0))

2do programa:

alert(eval(c="`alert(eval(c=${JSON.stringify(c)},n=${+!n}))`",n=1))

Esto se basa en la respuesta de Herman Lauenstein a Tri-interquine

Javascript (código fuente de lecturas no válidas), 75 + 75 = 150 61 + 61 = 122 58 + 58 = 116 50 + 50 = 100 bytes

ahorró 20 bytes gracias a Tushar, 6 bytes gracias a Craig Ayre, y guardó 16 bytes gracias a kamoroso94

1er programa:

f=_=>alert(("f="+f).replace(0,a=>+!+a)+";f()");f()

2do programa:

f=_=>alert(("f="+f).replace(1,a=>+!+a)+";f()");f()

Intercambia los 1 con los 0 y viceversa. Ambos hacen lo mismo, solo producen resultados diferentes debido a su código fuente.

Python 2, 63 + 63 = 126 bytes

Pruébalo en línea

Primer programa:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

salidas:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

Segundo programa:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

Salidas:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

JavaScript ( JsShell ), 35 + 34 = 69 bytes

1:

(f=x=>print(`(f=${f})(${-x})`))(-1)

2:

(f=x=>print(`(f=${f})(${-x})`))(1)

Mathematica, 43 + 44 = 87 bytes

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -1 1]

y

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -(-1)]

asmutils sh, 16 + 16 bytes, abusando de la regla "stdin is closed".

#!/bin/sh
tr x y

Dado que stdin está cerrado y sh abrirá su script en el primer controlador disponible (en lugar de moverlo a un controlador con un número alto como lo hacen los shells modernos), tr termina leyendo una copia del script sin haberlo abierto nunca.

Este interquine es capaz de cargar, pero insertar una carga útil es complicado.

Además, esta versión original abusa de algunos errores locos en el núcleo antiguo que usaba en esos días. (No sé qué pasa con ese kernel, descubrí más tarde que también tenía diferentes números mayores y menores para los dispositivos). Si corrige los cambios de ABI que se rompieron como asmutils, la interquina aún no funcionará. Olvidé si asmutils sh tiene ejecutivo o no, pero si lo tiene, esta es una versión moderna:

exec dd skip=0 | tr x y

Esto abusa de un error deliberado en asmutils dd; tiene una optimización de rendimiento que llama a llseek para omitir si puede, pero para guardar un byte pasa SEEK_SET en lugar de SEEK_CUR. Esto da como resultado basura en stderr pero la interquina en stdout. Asmutils dd no tiene una opción para suprimir el correo basura más stderr.

Baja carga , 32 + 32 = 64 bytes

(a~a*(:^)*S)(~(a)~a*^a(:^)**S):^

Pruébalo en línea!

(~(a)~a*^a(:^)**S)(a~a*(:^)*S):^

Pruébalo en línea!

Lisp común, 58 caracteres

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

... o 24 caracteres si no le importa suponer que *print-circle*está configurado globalmente en T:

#1=(print '(write '#1#))

La representación impresa del código se lee como una estructura cíclica, donde #1#apunta de nuevo a la siguiente celda de contras #1=. Cotizamos programas para que no se ejecuten. Como *print-circle*es T, el REPL se encarga de emitir tales variables de lectura durante la impresión; esto es lo que imprime el código anterior y devuelve:

#1=(write '(print '#1#)) 

Cuando evaluamos el código anterior, imprime:

#1=(print '(write '#1#))

Si desea mantener el valor predeterminado para *print-circle*, que es NIL en una implementación conforme, deberá volver a vincular la variable temporalmente:

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

Dentro del cuerpo del LET, imprimimos cosas con *print-circle*ser T. Entonces obtenemos:

#1=(write
    '(let ((*print-circle* t))
       (print '#1#))
    :circle t) 

Como puede ver, el nuevo programa no se vuelve a unir *print-circle*, pero como estamos utilizando write, que es la función de bajo nivel llamada por print, podemos pasar argumentos adicionales como :circle. El código entonces funciona como se esperaba:

#1=(let ((*print-circle* t))
     (print '(write '#1# :circle t)))

Sin embargo, debe ejecutar los programas anteriores como un script, no dentro de un REPL, porque a pesar de que imprime las cosas mientras se ocupa de las estructuras circulares, ambas writey printtambién devuelve el valor que se está imprimiendo; y en un REPL predeterminado, el valor también se imprime, pero fuera del contexto dinámico donde *print-circle*está T.

> <> , 16 + 16 = 32 bytes

":1-}80.r   !#o#

y

#o#!   r.08}-1:"

Pruébalo en línea!

Esto funciona mediante el uso de un salto en el programa, el primer salto de los programas omitirá el reverso de la pila (si revierte la pila, sería una quine). El segundo programa no omite el reverso, pero si ya está invertido por el flujo del programa, creará el original.

Este código terminará en un error.

RProgN 2 , 7 + 7 = 14 bytes

Quería intentar mostrar un mejor uso de RProgN, en lugar de abusar de las órdenes de impresión ...

1
«\1\-

y...

0
«\1\-

Explicado

1   # Push the constant, 1. (Or 0, depending on the program)

«\1\-
«       # Define a function from this to the matching », in this case there isn't any, so define it from this to the end of the program, then continue processing.
 \      # Flip the defined function under the constant.
  1\-   # Get 1 - Constant.

Debido a que esto imprime la pila al revés, primero se imprime la nueva constante, luego se imprime la versión en cadena de la función.

Pruébalo en línea!

LOGOTIPO , 65 + 66 = 131 bytes

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] 1]

y

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] -1]

Python 3, 74 + 74 = 148 bytes

a='a=%r;b=%r;print(b%%(b,a))';b='b=%r;a=%r;print(a%%(a,b))';print(b%(b,a))

y

b='b=%r;a=%r;print(a%%(a,b))';a='a=%r;b=%r;print(b%%(b,a))';print(a%(a,b))

yo tampoco lo entiendo

> <> , 12 + 12 = 24 bytes

'3d*!|o|!-c:

y

':c-!|o|!*d3

Pruébalo en línea!

Ambos programas usan un literal de cadena de ajuste para agregar el código a la pila, luego producen el 'comando a través de diferentes métodos. Al imprimir la pila, empuja el código hacia atrás, sin embargo, se 'queda al frente. Hay varias variaciones que producen el '; 3d*, d3*, 00g, :c-Cuando se combina con 3d*y:9- cuando se combina con00g .

Una solución demasiado similar para publicar, en Befunge-98 para 13 * 2 bytes

"2+ck, @,kc+2

Stax , 18 + 20 = 38 bytes

"Vn|^34bL"Vn|^34bL

¡Ejecute y depure en línea!

"Vn|^34bL
"Vn|^34bL

¡Ejecute y depure en línea!

Explicación

Añadido para completar. Puerto de la respuesta CJam de @ jimmy23013 Alterna las líneas nuevas usando set xor.

Javascript (ES6), 36 + 36 = 72 bytes

Programa 1:

f=n=>('f='+f).replace(/4|5/g,n=>n^1)

Programa 2:

f=n=>('f='+f).replace(/5|4/g,n=>n^1)

Estos programas funcionan clonándose y reemplazados 5por 4y 4con5

console.log((
    f=n=>('f='+f).replace(/4|5/g,n=>n^1)
)())
console.log((
    f=n=>('f='+f).replace(/5|4/g,n=>n^1)
)())

Klein , 26 24 bytes

<:3+@+3<:"

Pruébalo en línea!

Explicación

Esto funciona igual que mi Klein Quine , donde imprime la fuente hacia atrás seguida de una ", la última se salio con la suya al ser palindrómica, por lo que todo lo que tenemos que hacer es hacerla no palindrómica sin dañar su funcionalidad. Al cambiar <y :pudimos hacer esto sin interferir con la funcionalidad.

Pari / GP , 36 + 36 = 72 bytes

(f=(x)->print1("(f="f")("1-x")"))(1)

Pruébalo en línea!

(f=(x)->print1("(f="f")("1-x")"))(0)

Pruébalo en línea!