程序A在运行时输出程序B的代码，而B输出A的源代码。

要求：

• 两种程序中只有一种语言
• 程序不同。输出自身的一个程序不符合条件。
• 这两个程序都是非空的，或者长度至少为1个字节。源和输出中的尾随换行符都将被忽略
• stdin已关闭。不要阅读任何内容（因此您无法阅读源代码并对其进行操作）。输出进入标准输出。
  编辑： stdin连接到/dev/null。如果明确说明，您可以命令将其关闭。
• 不要使用random功能。

额外：

• 如果可能，给出解释

分数是总长度。如果尾随换行不影响程序，则不算在内。

CJam，13 + 13 = 26个字节

{sYZe\"_~"}_~

在线尝试！

产出

{sZYe\"_~"}_~

说明

{       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.
}_~

由于e\第二个和第三个操作数是可交换的，因此其他程序执行的操作完全相同，交换Z并Y返回其原始顺序。

CJam，11 + 13 = 24 11 + 12 = 23字节

"N^_p"
N^_p

在线尝试！

输出：

"N^_p
"
N^_p

输出有13个字节，但是：

如果尾随换行不影响程序，则不算在内。

因此，我将空间更改为换行符以利用这一点。

它基于最短的CJam适当的quine：

"_p"
_p

并且N^是用一个换行符对字符串进行异或运算，如果没有换行符，则会添加一个换行符；如果存在换行符，则将其删除（对于每个字符都是唯一的字符串）。

我想我已经在quine问题中看到了那个quine，但是找不到。

RProgN 2，3 + 3 = 6字节

第一个程序：

0
1

在线尝试！

第二个程序：

1
0

在线尝试！

-2感谢Martin Ender。

C，95 + 95 = 190字节

感谢@immibis节省了16 * 2字节！

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

在线尝试！

输出：

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

在线尝试！

哪个输出：

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字节

第一个程序：

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

第二程序：

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

这基于赫尔曼·劳恩斯坦（Herman Lauenstein）对Tri-interquine的回答

Javascript（无效读取源代码），75 + 75 = 150 61 + 61 = 122 58 + 58 = 116 50 + 50 = 100字节

Tushar节省了20个字节，Craig Ayre节省了6个字节，kamoroso94节省了16个字节

第一个程序：

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

第二程序：

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

将1与0交换，反之亦然。他们俩都做同样的事情，只是由于它们的源代码而产生不同的输出。

Python 2、63 + 63 = 126个字节

在线尝试

第一个程序：

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

输出：

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

第二个程序：

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

输出：

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

JavaScript（JsShell），35 + 34 = 69字节

1：

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

2：

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

Mathematica，43 + 44 = 87字节

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

和

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

sh asmutils sh，16 + 16字节，滥用“ stdin已关闭”规则。

#!/bin/sh
tr x y

由于关闭了stdin，并且sh会将其脚本打开到第一个可用的句柄（而不是像现代shell那样将其移至编号较高的句柄），因此tr最终会在没有打开脚本的情况下从脚本副本中读取内容。

该互连网具有有效负载能力，但是插入有效负载是棘手的。

另外，这个原始版本滥用了我当时使用的古老内核中的一些疯狂错误。（我不知道该内核的功能-我后来发现它在设备上也有不同的主要和次要编号。）如果您修复了中断了混乱的ABI更改，则仍然无法使用间隔。我忘记了asmutils sh是否具有exec，但是，如果有，这是一个现代版本：

exec dd skip=0 | tr x y

这会滥用asmutils dd中的故意错误；它具有性能优化功能，如果可以的话，它会调用llseek进行跳过，但是要保存一个字节，它将传递SEEK_SET而不是SEEK_CUR。这会在stderr上导致垃圾，而在stdout上会导致interquine。Asmutils dd没有抑制stderr垃圾邮件的选项。

欠载，32 + 32 = 64字节

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

在线尝试！

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

在线尝试！

普通Lisp，58个字符

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

...或24个字符（如果您不介意假设*print-circle*全局设置为）T：

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

该代码的打印表示形式以循环结构的形式读取，其中#1#指向后面的cons单元#1=。我们引用程序，以便不执行它们。由于*print-circle*为T，REPL会在打印过程中小心地发出此类读取器变量。这是上面的代码打印并返回的内容：

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

当我们评估以上代码时，它会打印：

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

如果您要使用的默认值（*print-circle*在符合标准的实现中为NIL），则必须暂时重新绑定变量：

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

在LET的主体内，我们将事物打印*print-circle*为T。因此，我们获得：

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

如您所见，新程序不会重新绑定*print-circle*，但是由于我们正在使用write，这是by调用的低级函数print，因此我们可以传递其他参数，例如:circle。该代码然后按预期方式工作：

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

但是，您需要执行上述计划为脚本，而不是一个REPL里面，因为即使你打印的东西，同时照顾圆形结构，都write和print还返回正在打印的价值; 在默认的REPL中，该值也将被打印，但在动态上下文*print-circle*T 之外。

> <>，16 + 16 = 32字节

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

和

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

在线尝试！

这是通过在程序中使用跳转来实现的，第一个程序跳转将跳过堆栈的反转（如果它反转了堆栈，那将是一个quine）。第二个程序不会跳过相反的过程，但是如果它已经被程序的流程逆转了，那么它将创建原始的。

该代码将以错误结尾。

RProgN 2，7 + 7 = 14字节

我想展示一种更好地使用RProgN的方法，而不仅仅是滥用打印命令...

1
«\1\-

和...

0
«\1\-

讲解

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.

因为这会颠倒打印堆栈，所以先打印新常量，然后打印函数的字符串化版本。

在线尝试！

LOGO，65 + 66 = 131字节

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

和

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

Python 3，74 + 74 = 148字节

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

和

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

我也不明白

> <>，12 + 12 = 24字节

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

和

':c-!|o|!*d3

在线尝试！

这两个程序都使用包装字符串文字将代码添加到堆栈中，然后'通过不同的方法生成命令。当打印堆栈时，它将代码向后推，但是'位于最前面。有几种变体会产生'；3d*，d3*，00g，:c-当配对3d*，并:9-在与配对00g。

过于相似的解决方案，在Befunge-98中发布13 * 2字节

"2+ck, @,kc+2

Stax，18 + 20 = 38字节

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

在线运行和调试！

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

在线运行和调试！

说明

为完整性而添加。@ jimmy23013的CJam答案的端口。使用set xor切换换行符。

Javascript（ES6），36 + 36 = 72字节

程序1：

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

程式2：

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

这些程序通过克隆自己工作和替换5用4，并4用5

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字节

<:3+@+3<:"

在线尝试！

说明

这与我的Klein Quine的工作原理相同，在Klein Quine中，它向后打印源，然后打印a "，最后一个通过回文避免了该问题，因此我们要做的就是使它成为非回文的而不损坏其功能。通过切换<，:我们能够做到这一点而不会干扰功能。

Pari / GP，36 + 36 = 72字节

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

在线尝试！

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

在线尝试！