目的：

对两个程序进行编码，每个程序输出两个源代码，每个源代码都按字符隔行扫描，例如拉链，双缝Quine。双缝Quine的输出从第一个程序的源代码中的第一个字符开始。如果其中一个程序的源代码的长度短于另一个程序的源代码，则输出的其余部分必须用其余较长的源代码填充。

规则：

1. 您可以对两种程序使用任何编程语言，而不必对两种程序使用相同的编程语言。
2. 您的程序不应从文件，文件名，网络，其他程序或其他任何内容中获取任何输入。

强制标准：

• 有一个陷阱，在输出中的某个位置QUINE必须存在不间断的大写字母单词。
• 您需要说明正在使用的两种编程语言。如果两种语言都使用相同的编程语言，则只需声明一种编程语言。
• 这两个程序都应该能够独立于另一个程序执行或解释。

例：

拥有程序一的示例源代码：

"QIE"

拥有程序2的示例源代码：

"UN"

然后，两个程序的有效双缝Quine输出必须为：

""QUINE""

这是代码高尔夫球，将两个源代码的长度加起来，并且显然将每个程序输出的长度加起来，最少的字节也很成功！

CJam，49个 47字节

{`:_"__~~e#QUINE"}_~

和

{`:_"__~~e#QUINE"}_~e#QUINE

都打印

{{``""__~~""++::__""ee##QQUUIINNEE""}}__~~e#QUINE

在线尝试：程序1，程序2，有效期证明

他们如何工作

{                }   e# Push a code block.
                  _~ e# Execute a copy.
 `                   e# Convert the code block into a string.
  :_                 e# Duplicate each character of the resulting string.
    "__~~e#QUINE"    e# Push this string.

程序1到此结束，它具有整个源代码的字符串表示形式（每个字符重复两次），以及堆栈上的字符串e＃QUINE。

程序2还分析了e#QUINE，这是一个注释。

在这两种情况下，CJam都会自动打印两个字符串，从而产生上述输出。

严重的是46 56 42字节

QUNX;RZtdXεj.ƒ£REIQ

十六进制转储：

51554e583b525a746458ee6a2e7f9f9c524549510a

第二个程序就是这个完全相反的程序。它确实包含一个不可见的字符，但是字节数正确。这两个程序都输出以下回文字符串：

QQUINEXR;£RƒZ⌂t.djXεεXjd.t⌂ZƒR£;RXENIUQQ

（由于某种原因，它在终端中输出时会显示不可见的字符。我不太理解那个7F字节。）

怎么运行的：

Q                     Push the source to the stack
 U                    Nop
  NX                  Push and pop lyrics to 99 bottles of beer
    ;R                Make a copy of the source reversed.
      Z               Zip them together.
       t              Completely flatten the list.
        dX            Delete the trailing newline
          εj          Join it into a string.
            .         Print it with a trailing newline.
             ⌂        (This is that 7F byte that won't show up. It halts.)

程序的其余部分未执行。

然后另一个方向：

\n                   Nop
  Q                  Push the source code.
   IE                Nops
     R               Reverse source code to get source of first program
      £              Eval it into a function
       ƒ             Call it.

至此，我们现在正在运行上面的第一个程序，因此执行将如此处所述继续进行。

我大量利用了以下事实：几个命令对字符串或空堆栈都不起作用。我还利用t了堆栈中只有一项的意外行为。不要指望该程序在“严重”的将来版本中可以使用。

随着认真解释器的在线版本继续被破坏，您将必须下载解释器并在您自己的计算机上运行它以对其进行测试。

GolfScript，46个字节

{`{.}%"..~~QUINE"}.~

和

{`{.}%"..~~QUINE"}.~QUINE

都打印

{{``{{..}}%%""....~~~~QQUUIINNEE""}}..~~QUINE

在线尝试：程序1，程序2，有效期证明

怎么运行的

{`{.}%"..~~QUINE"}.~

{                }    # Push a code block.
                  .~  # Execute a copy.
 `                    # Convert the code block into a string.
  {.}%                # Duplicate each character of the resulting string.
      "..~~QUINE"     # Push that string.

程序2的源代码另外解析了QUINE\n，这是两个未定义的标记。

Perl，61 + 60 = 121字节

程序1：

$x=q<print"\$x=q<$x>;eval\$x#"=~s/./$&$&/gr,QUINE>;eval$x#QIE

程式2：

$x=q<print"\$x=q<$x>;eval\$x#"=~s/./$&$&/gr,QUINE>;eval$x#UN

我以为我会以非高尔夫语言来尝试一下。基本上，这只是Perl中的通用quine构造函数，将其修改为在打印每个字符之前将其加倍，然后追加QUINE到末尾。然后，我们只需要在代码末尾添加注释以补偿添加的文本。

（我写这篇文章时并没有真正看过其他答案。事实证明，可以通过将整个注释放在一个程序中来节省一个字节，但是我不确定是否应该公然复制这样的算法。）