Programa A emite o código do programa B quando executado, e B emite a fonte de A.

Requisitos:

• Apenas um idioma nos dois programas
• Os programas são diferentes. Um programa que sai em si não se qualifica.
• Ambos os programas não estão vazios ou têm pelo menos 1 byte de comprimento. Novas linhas à direita na origem e na saída são ignoradas
• stdin está fechado. Não leia nada (portanto, você não pode ler a fonte e manipulá-la). A saída vai para stdout.
  Edit: stdin está conectado a /dev/null. Você pode solicitar que seja fechado se esclarecido.
• Não use randomfunções.

Adicional:

• Dê explicações, se possível

Pontuação é o comprimento total . A linha nova à direita não conta se não afetar o programa.

CJam , 13 + 13 = 26 bytes

{sYZe\"_~"}_~

Experimente online!

Saídas

{sZYe\"_~"}_~

Explicação

{       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\é comutativo em seu segundo e terceiro operando, o outro programa faz exatamente o mesmo, trocando Ze Yretornando à sua ordem original.

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

"N^_p"
N^_p

Experimente online!

Saídas:

"N^_p
"
N^_p

A saída possui 13 bytes, mas:

A linha nova à direita não conta se não afetar o programa.

Então, mudei o espaço para uma nova linha para aproveitar isso.

É baseado na menor quantidade adequada de CJam:

"_p"
_p

E N^é xor a sequência com uma nova linha, que adiciona uma nova linha se não houver uma nova linha e removê-la se houver, para uma sequência em que cada caractere seja único.

Acho que vi esse quine na pergunta quine, mas não o encontrei.

RProgN 2 , 3 + 3 = 6 bytes

Primeiro programa:

0
1

Experimente online!

Segundo programa:

1
0

Experimente online!

-2 graças a Martin Ender .

C, 95 + 95 = 190 bytes

Obrigado a @immibis por salvar 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);}

Experimente online!

Saídas:

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

Experimente online!

Quais saídas:

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

1º programa:

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

2º programa:

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

Isto é baseado na resposta de Herman Lauenstein ao Tri-interquino

Javascript (código-fonte de leituras inválidas), 75 + 75 = 150 61 + 61 = 122 58 + 58 = 116 50 + 50 = 100 bytes

economizou 20 bytes graças a Tushar, 6 bytes graças a Craig Ayre e economizou 16 bytes graças a kamoroso94

1º programa:

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

2º programa:

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

Troca os 1s pelos 0s e vice-versa. Ambos fazem a mesma coisa, apenas produzindo resultados diferentes devido ao seu código-fonte.

Python 2, 63 + 63 = 126 bytes

Experimente online

Primeiro programa:

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

saídas:

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]

Saídas:

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]

e

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

asmutils sh, 16 + 16 bytes, abusando da regra "stdin is closed".

#!/bin/sh
tr x y

Como o stdin está fechado e o sh abrirá seu script para o primeiro identificador disponível (em vez de movê-lo para um identificador de número alto, como os shells modernos), tr termina lendo uma cópia do script sem nunca ter aberto.

Essa interquina é capaz de carga útil, mas inserir uma carga útil é complicado.

Além disso, esta versão original abusa de algum bug maluco no kernel antigo que eu usei naqueles dias. (Eu não sei o que há com esse kernel - descobri mais tarde que ele também possui diferentes números maiores e menores para dispositivos.) Se você corrigir as alterações da ABI que se quebraram, o interquino ainda não funcionará. Eu esqueço se o asmutils sh tem exec ou não, mas se tiver, esta é uma versão moderna:

exec dd skip=0 | tr x y

Isso abusa de um erro deliberado no asmutils dd; possui uma otimização de desempenho que chama llseek para skip, se puder, mas para salvar um byte, passa SEEK_SET em vez de SEEK_CUR. Isso resulta em lixo no stderr, mas no interquine no stdout. O Asmutils dd não tem uma opção para suprimir o spam stderr.

Carga insuficiente , 32 + 32 = 64 bytes

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

Experimente online!

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

Experimente online!

Lisp comum, 58 caracteres

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

... ou 24 caracteres, se você não se importa em assumir que *print-circle*está globalmente definido como T:

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

A representação impressa do código é lida como uma estrutura cíclica, onde #1#aponta para a célula de contras a seguir #1=. Citamos programas para que não sejam executados. Como *print-circle*é T, o REPL cuida de emitir essas variáveis ​​do leitor durante a impressão; é isso que o código acima imprime e retorna:

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

Quando avaliamos o código acima, ele imprime:

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

Se você deseja manter o valor padrão para *print-circle*, que é NIL em uma implementação em conformidade, será necessário religar a variável temporariamente:

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

Dentro do corpo do LET, imprimimos as coisas como *print-circle*sendo T. Portanto, obtemos:

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

Como você pode ver, o novo programa não é religado *print-circle*, mas como estamos usando write, que é a função de baixo nível chamada por print, podemos passar argumentos adicionais, como :circle. O código funciona como esperado:

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

No entanto, você precisa executar os programas acima como um script, não dentro de um REPL, porque, embora você imprima coisas enquanto cuida de estruturas circulares, ambos writee printtambém retorna o valor que está sendo impresso; e em um REPL padrão, o valor também está sendo impresso, mas fora do contexto dinâmico em que *print-circle*é T.

> <> , 16 + 16 = 32 bytes

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

e

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

Experimente online!

Isso funciona usando um salto no programa; o primeiro salto de programas pulará o reverso da pilha (se invertida, seria uma solução). O segundo programa não pula o inverso, mas já foi revertido pelo fluxo do programa, cria o original.

Este código terminará em um erro.

RProgN 2 , 7 + 7 = 14 bytes

Eu queria tentar mostrar um melhor uso do RProgN, em vez de apenas abusar dos pedidos de impressão ...

1
«\1\-

e...

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.

Como isso imprime a pilha de cabeça para baixo, a nova constante é impressa primeiro e, em seguida, a versão com strings da função é impressa.

Experimente online!

LOGO , 65 + 66 = 131 bytes

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

e

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

e

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

eu também não entendo

> <> , 12 + 12 = 24 bytes

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

e

':c-!|o|!*d3

Experimente online!

Ambos os programas usam uma literal de seqüência de caracteres de empacotamento para adicionar o código à pilha e, em seguida, produzir o 'comando através de métodos diferentes. Ao imprimir a pilha, ele empurra o código para trás, mas 'permanece na frente. Existem várias variações que produzem o '; 3d*, d3*, 00g, :c-Quando emparelhado com 3d*e :9-quando combinado com00g .

Uma solução muito semelhante para postar, no Befunge-98 por 13 * 2 bytes

"2+ck, @,kc+2

Stax , 18 + 20 = 38 bytes

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

Execute e depure online!

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

Execute e depure online!

Explicação

Adicionado para completar. Porto da resposta CJam de @jimmy23013. Alterna as novas linhas usando o conjunto 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)

Esses programas funcionam clonando-se e substituindo 5por 4e 4com5

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

Experimente online!

Explicação

Isso funciona da mesma forma que o meu Klein Quine , onde imprime a fonte de trás para frente, seguida por a ", a última se safou disso por ser palindrômica, então tudo o que precisamos fazer é torná-la não palindrômica sem danificar sua funcionalidade. Ao mudar <e :fomos capazes de fazer isso sem interferir com a funcionalidade.

Pari / GP , 36 + 36 = 72 bytes

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

Experimente online!

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

Experimente online!