metaquine是一个不是quine的程序，但是当以相同语言作为程序运行时，其输出是quine。

这项挑战的目标是编写一个metaquine。这是代码高尔夫球，因此最短的代码获胜，最早的答案用作决胜局。请注意，由于quine的定义，只接受完整程序。

规则

仅接受真正的奎因。也就是说，您需要将整个源代码原样打印到STDOUT，而无需：

• 直接或间接阅读您的源代码。
• 依靠REPL环境，该环境仅评估并打印您提供给它的每个表达式。
• 依靠在某些情况下仅能打印出源代码的语言功能。
• 使用错误消息或STDERR编写全部或部分的藜。（您可以将内容写到STDERR或产生警告/非致命错误，只要STDOUT是有效的Quine，并且错误消息不属于其中即可。）
• 源代码完全由文字（无论是字符串文字，数字文字等）和/或NOP组成。

为了有效，可以在输出中忽略任何不可抑制的输出（例如版权声明，启动/关闭消息或尾随换行符）。

例

忽略禁止纯文字程序和内置quining的规则，这在严重中将是一个metaquine：

"Q"

该程序由单字符串文字组成，该字符串"Q"在输出中隐式打印。Q运行输出（）时，它是一个quine（Q是内置的quine函数）。

CJam，6个字节

"_p"_p

版画

"_p"
_p

这是CJam中最短的适当的奎因

在这里测试。

说明

这两个程序的工作原理完全相同，这是因为适当的五线组内部的换行符是空操作，仅包含在内，因为从输出中删除换行符更加昂贵。程序如何工作：

"_p"  e# Push this string.
_     e# Duplicate it.
p     e# Print a string representation of the top of the stack (i.e. the string with
      e# quotes) followed by a linefeed.
      e# The other copy is then printed automatically at the end of the program, without
      e# stringifying it.

边注

在GolfScript中与

".p".p

哪个打印

".p"
.p

带有尾随的换行符，这又是已知的最短的quines之一。

Pyth，12 11 10 9字节

多亏了@ Pietu1998，才淘汰了一个字节。

jN B".[9N

此打印

.[9N".[9N

这是Pyth中的奎因。您可以在这里尝试。

裂变，6个字节

!+OR"'

版画

'!+OR"

这是最短的裂变奎因。之所以有效，是因为程序的循环移位使其输出完全不受影响。

在线尝试！

Javascript ES6，21个字节

$=_=>`$=${$};$()`
$()

不重要的。

Python 2，29个字节

_="_=%r;print _%%_";print _%_

原来众所周知的短python quine很容易变成metaquine :)

而且，由于我们不必担心匹配尾随的换行符，因此，metaquine实际上更短！

Japt，15 13字节

Q+"+Q ³s7J" ²

在线测试！

该程序输出

"+Q ³s7J"+Q ³s7J

这是Japt中已知最短的藜。

怎么运行的

Q+"..." // Take a quotation mark plus this string.  "+Q ³s7J
²       // Repeat it twice.                         "+Q ³s7J"+Q ³s7J
        // Implicit output

非竞争版本，11字节

Q+"+Q ²é" ²

我刚刚添加 é了“旋转”命令。所以

"+Q ²é"+Q ²é

现在是有效的奎因。

露比25岁23

puts"puts <<2*2,2
"*2,2

生成经典的Ruby HEREdoc quine

puts <<2*2,2
puts <<2*2,2
2

旧解决方案

_='_=%p;$><<_%%_';$><<_%_

生成自身，但单引号替换为双引号。

JavaScript，50个字节

a="a=%s;console.log(a,uneval(a))";eval(a.slice(5))

基于man已知的最短的非源代码读取JS quine，但要短8个字节。版画

a="a=%s;console.log(a,uneval(a))";console.log(a,uneval(a))

这是一个藜。

鱼（> <>），17个字节

这可以使用经典的鱼quine来工作，"r00g!;oooooooo|但是会添加一个{将整个堆栈向左移动的，以便原始程序不是quine，但是运行时它的输出是。

"{r00g!;oooooooo|

输出：

"r00g!;oooooooo|

这是鱼片！

果冻，3 个字节（无竞争）

不幸的是，所需的原子比挑战要年轻大约两周。

间喹

”Ṙv

在线尝试！

怎么运行的

”Ṙv  Main link. No arguments.

”Ṙ   Set the left argument and the return value to the character 'Ṙ'.
  v  Dyadic eval; evaluate the return value with the left argument as argument.
     Executing the atom Ṙ on the argument 'Ṙ' prints a string representation of
     the character, i.e., the string "”Ṙ".
     Finally, v returns its unaltered argument, which is printed implicitly.

奎因

”ṘṘ

在线尝试！

怎么运行的

”ṘṘ  Main link. No arguments.

”Ṙ   Set the left argument and the return value to the character 'Ṙ'.
  Ṙ  Print a string representation of the character, i.e., the string "”Ṙ".
     (implicit) Print the unaltered return value.

由于第二个Ṙ打印了前两个字符（”Ṙ），因此根据我们的定义，这是一个合适的字符串。

Octopen-Baru，22个字节

**非竞争性答案

愛[35211].pack歩U')

Ruby输出

puts [35211].pack(' U')

哪个输出見。在Octopen-Baru中，这是奎因！

7，2个字节，语言晚于挑战

该程序有两个字节长，可以用多种方式解释。作为十六进制转储：

00000000: 4ff4                                     O.

如代码页437所示：

O⌠

或者，最可理解的是，以八进制表示（这是本机使用的八进制）：

237723

在线尝试！

它的工作原理非常简单：这是标准的7 quine，在两半之间插入了一个无操作堆栈元素，以使其与众不同（在此情况下，7将堆栈元素分开）。（我也可以在开始时插入它723723。。由于结尾的7s就像结尾的空格一样，我无法在结尾处解释它，并且在打包编码中被忽略，因此它与输出程序没有任何不同。 ）

顺便说一句，该程序是十六进制的回文，但是这仅仅是巧合。

欠载，11个字节

(:aSS)::aSS

很简单 它会打印出(:aSS):aSS，这是标准的Underload quine。

Brachylog，12个字节

"~k;?w₁"gjw₃

在线尝试！

我从Fatalize的Brachylog v1（非作弊）奎因翻译的quine的132个等长变基喹之一。实际上，我编写了一个（无毛的，总体上很愚蠢的）程序来将它们全部打印出来：

{[[";?","gj","jḍ"],"₁₃₅₇"]j∋ᵐ{ḍ≠&};"\"~~k~ww~w\"~ww~w~n"}ᶠ{lw" metaquines generated:
"ẉ&}w₁ᵐ

在线尝试！

有原奎因的两个部分可以前后不一致代替：;?可改为gj或者jḍ，并且₁可以改变₃，₅或₇。如果我们以一种方式在字符串文字外部和在字符串文字内部以不同的方式保留或更改它们，则输出将与源不匹配，因为字符串文字中存在的任何变体都会在字符串的内部和外部打印，导致不是最初程序运行的quine。

;?，，gj和jḍ是可互换的，因为这三者都将字符串文字与自身配对：由于程序的布局，输入变量?与字符串统一，因此;?将字符串与自身配对；无论布局如何，都gj将字符串包装在一个列表中，然后将其串联起来；同样jḍ将字符串连接到自身，然后将其分成两半。

奇数w下标是可互换的，因为尽管最初w只能取0或1，其中0将输入打印到输入w，1将第一个元素格式化为第二个元素，但下标清单w已发展为外部可作为位域的对象：下标的低位编码是直接格式还是格式化的，中位编码是否来自以下位置的输出变量w不受限制或设置为输入，并且高该位编码打印是立即完成还是延迟到程序结束，以便可以进行回溯。（这些下标是我对Brachylog的第一个也是迄今为止最大的贡献。）由于quine和metaquine不使用输出变量，也不回溯，所以所有四个奇数下标都是等效的。

Befunge-93，22个字节

"+1_@#`+39:,g0:">:#,_@

我只是采用了标准的奎因，将其用引号引起来，将其反转（这样就可以正确地将其加载到堆栈上），然后在最后添加一个堆栈打印。

在普通的quine中增加了8个字符，因此很有可能有更好的解决方案。

Turtlèd，52字节（非竞争）

比原始奎尼少1

@##'@r,r,r-{ +.r_}r{ +.r_}"#'@r,r,r-{ +.r_}r{ +.r_}"

以相同的方式工作，除了它的末尾没有字符，在运行时，它将在末尾有一个字符，不会影响输出，因为它将＃写入＃。请注意，输出结果与我为进行quine挑战而制作的quine稍有不同，但工作原理相同：“写＃，这是它自己的最后一个字符，就像我制作的quine。在此处查看说明。

Lua，45个字节

完整的代码不是我的。

s="s=%qprint(s:format(s))"print(s:format(s));

将导致

s="s=%qprint(s:format(s))"print(s:format(s))

这是一个藜。很高兴在Lua中;是可选的。

Pushy，7个字节

语言不具有竞争性会推迟挑战。

这是标准的奎因，但删除了换行符。换行符在Pushy中没有任何意义，但是是打印操作员的标准分隔符，因此对于真正的包装来说是必需的。

95 34_"

在线尝试！输出：

95 34
_”

这是最短的Pushy quine-有关其工作原理的说明可在此处找到。

另外，也H5-34_"可以使用相同的字节数。

泡沫，14个字节

[. .'|: ~|]: ~

这将打印出第二个可以在此处找到的泡沫奎因。这实际上较短，因为.它将始终在每个元素之间放置一个空格，但是第三个标记中的横条允许我省略它之前的空格。

外壳，6个字节

D"S+s¨

在线尝试！

打印标准的Husk quine S+s"S+s"。

 "S+s¨    The string S+s"
D         concatenated with itself.

奎因解释说：

   "S+s"    The string S+s
 +          concatenated with
S           itself passed through
  s         the function which returns its string representation.