您的目标是创建一个可以无限打印的程序，并在每行之后添加一个新行。因此，如果您的程序是单行程序，那么它将在输出的每一行上重复执行。

例

程序：

A

输出：

A
A
A
...

规则

• 它必须是完整的程序，而不是摘要或功能。
• 该程序应永远循环，而不会出现堆栈溢出或递归限制错误。
• 输出是标准输出或最接近的替代输出。
• 不接受任何程序输入。
• 不允许出现标准漏洞，例如打开程序的文件或访问外部资源。空程序不允许作为标准漏洞。
• 如果您的程序代码以尾随换行符结尾，则这不算作成对字符之间的必要换行符，您必须打印另一个。
• codegolf-最短的代码胜出！

裂变，7个字节

'!+!NR"

到目前为止，我发现了最短的Fission quine的一个相当简单的修改：我只是在使用非破坏性!代替，而是为换行符O添加了一个N。

因此，总而言之，这是它的工作原理：控制流始于R正确的原子。"切换字符串模式，这意味着一切都将"打印到下一个：在这种情况下'!+!NR。这样"就可以打印和换行符了。'!将原子的质量设置为33，将其质量+增加为34（字符代码为"）并!打印引号。N打印换行符，R在这种情况下现在是空操作，因此循环从头开始。

以下7字节解决方案也可以使用：

"NR'!+!

> <>，16个字节

'ard3*o50l2)?.~~

传统的<> quine使用太多os，因此我们使用循环进行打印。在每次跳转之前，我们先按5和0（要跳转到的位置的坐标），之后.如果有需要打印的内容，则跳转至，或者使用弹出前两个值~~。

（由于我忘记了堆栈溢出规则，因此恢复为16版本。）

CJam，13个字节

{_o"_g
"o1}_g

在线解释器在程序终止之前不会打印任何内容，因此您必须在Java解释器中进行测试。

说明

最后，一个广义的CJam quine不以_~。

{_o"_g
"o1}

这只是推一个障碍。_g复制该块并重复执行，而堆栈的顶部为真（丢弃条件）。

现在在该块内部，该块的另一个副本仍在堆栈中。我们复制并用进行打印_o，然后在印刷_g后加上换行符（quines之间需要的额外换行符）"_g\n"o。最后，我们将a压入1堆栈以使循环重复进行，因为不幸的是，在CJam中，块不是真实的（或虚假的）。

蟒蛇2，39

在Python中并不是一件非常有趣的任务，因为将while循环添加到普通的Quine并不容易。

c='while 2:print"c=%r;exec c"%c';exec c

Perl 5.10 +，40 37字节

$_=q{say"\$_=q{$_};eval"while 1};eval

或（也是37个字节）

$_=q{{say"\$_=q{$_};eval";redo}};eval

用-M5.010或-E命令行标志调用，例如

$ perl -E '$_=q{say"\$_=q{$_};eval"while 1};eval'
$_=q{say"\$_=q{$_};eval"while 1};eval
$_=q{say"\$_=q{$_};eval"while 1};eval
$_=q{say"\$_=q{$_};eval"while 1};eval
...

感谢Ilmari Karonen从原始解决方案中削减了3个字节，这是：

eval while$_=q{say"eval while\$_=q{$_}"}

这以及上面较短的37字节解决方案，都是以下quine的简单变体，我在Ilmari的其他文章之一中第一次看到过：

$_=q{say"\$_=q{$_};eval"};eval

由于我在原始解决方案中添加的只是一个while循环，因此，他确实应得到大部分荣誉。:-)

自修改Brainf ***（SMBF），14字节

尾随的换行符\n必须是文字的Unix换行符（ASCII代码10）。

[<[<]>[.>]<.]\n

说明：

该代码将指针移至其源代码的最左侧，然后将其全部打印，包括换行符（规则的b / c两次）。循环继续。

PowerShell，143字节

$d='$d={0}{1}{0}{2}while(1){3}Write($d -f [char]39,$d,"`n",[char]123,[char]125){4}'
while(1){Write($d -f [char]39,$d,"`n",[char]123,[char]125)}

基于Rosetta Code PowerShell quine，我非常有信心这不是最短的。PowerShell中的字符串替换格式对此很讨厌，因为用于放置替换的相同定界符{}也分隔了代码块while{}，因此我们必须使用[char]强制转换，从而使代码code肿。

欠载，25个字节

第一次，我尝试过类似的操作，但不确定是否遵循所有规则，因为它有两行。换行有点麻烦。

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

Befunge，30 20字节

<,+55,*2+98_ #!,#:<"

流行的beunge quine的变体，它打印出换行符，如果结束该行，则在堆栈上弹出-1。
不幸的是，Befunge在一行中做事时变得冗长。我试图删除所有#可能的启动板（），但必须保留其中的一些启动板以跳过某些命令（例如,）。

变化：

30-20- >将基本Quine更改为我使用字符串输入进行的自定义。这样，分支就容易得多。

旧：

:0g,:93*`>0-10 #,+$#: #5 _1+>

我认为这不是最佳选择，但目前可以接受。

K，30个字节

{f:$_f;{x}{`0:f,"[]\n";1}/1}[]

R，34个字节

repeat{write(commandArgs()[5],'')}

从命令行调用如下：

Rscript -e "repeat{write(commandArgs()[5],'')}"

> <>，31个 29字节

对传统> <> quine的简单修改。

"ar00gc0.0+efooooooooooooooo|

要运行，请将其粘贴在此处，单击“提交”，然后单击“开始”（不运行动画不起作用）。随意提高执行速度。

Python 2，48个字节

c='c=\'%s\';while 1:print c%c';while 1:print c%c

GolfScript，16个字节

{.".do
":n\p}.do

最终看起来很像MartinBüttner的CJam条目。事实证明，一个有趣的功能是，".do"在打印块时追加到块的最短方法是将其分配给行终止符n。（当然，我们还需要在字符串中包括一个实际的换行符，以替换n通常包含的换行符。）同一字符串（在GolfScript中是真实的）也留在堆栈上，do以弹出循环，确保循环永远运行。

BASH，76个字节

只是无法抗拒，尤其是在这里使用PowerShell :)

while true;do
a ()
{
    echo while true\;do
    declare -f a
    echo a\;done
}
a;done

空格对于精确复制很重要。

Javascript（ES6），64

for(;;(_=>console.log(`for(;;(_=>${arguments.callee})());`))());

可替代的（也是64）

a="for(;;)console.log(`a=${JSON.stringify(a)};eval(a)`)";eval(a)

缩图稿，22字节

"f1{CqxCanx"f1{CqxCanx

基于从Esolangs文章奎因："fCqxah"fCqxah。充分利用了该语言根据需要自动附加右花括号的事实，如果没有该括号，则该花括号的长度将增加两个字节。

批处理，10个（文件名长度加4）

不知道这是否符合两个原因：

• 从技术上讲，Windows命令外壳可能会或可能不会产生文本方面的副作用，这取决于它的配置方式。
• 该程序通过名称来调用自身，我不确定规则（特别是“禁止打开程序文件”规则）是否禁止这样做。它不是为了阅读和打印文本而开放。它只是在重新运行本身。此外，文件系统结构是老式批处理脚本的组成部分（有时甚至被用于存储程序状态等）。因此，我不确定这是否违反了第5条规则。

代码（对于名为q.bat的程序）：

echo on&&q

锡兰，210个 208字节

当然，这不会赢任何东西。

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

原版的：

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(true){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(true){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

我从两天前通过添加while(true){...}循环修改了Quine，所以我从普通Quine的185个字节增加到210个（不再需要尾随换行符了）。但是后来我发现while(1<2){...}循环还要短两个字节：

shared void u(){value q="\"\"\"";value t="""shared void u(){value q="\"\"\"";value t=""";value b="""while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}""";while(1<2){print(t+q+t+q+";value b="+q+b+q+";"+b);}}

（锡兰没有for(;;)像Java那样的循环，该循环也需要大括号。）

PowerShell，132107字节

$a='$a={0}{1}{0};for(){2}$a-f[char]39,$a,[char]123,[char]125{3}';for(){$a-f[char]39,$a,[char]123,[char]125}

基于Rosetta Quine（与@AdmBorkBork相同），尽管不使用格式化来替换字符串...也许切换到for循环并使用格式化是最好的？

我敢肯定，如果AdmBorkBork回来了，他们会击败很多：P

编辑找出for循环和替换，这一切都要感谢我的前任:)

旧尝试：

$a='$a=;for(){$a.substring(0,3)+[char]39+$a+[char]39+$a.substring(3)}';for(){$a.substring(0,3)+[char]39+$a+[char]39+$a.substring(3)}

Ruby，41 39字节

对此处找到的其中一个Ruby quines的修改。

_="_=%p;loop{puts _%%_}";loop{puts _%_}

Java 10，194个字节

interface M{static void main(String[]a){for(var s="interface M{static void main(String[]a){for(var s=%c%s%1$c;;)System.out.println(s.format(s,34,s));}}";;)System.out.println(s.format(s,34,s));}}

说明：

在线尝试（60秒后超时）。

interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    for(var s="interface M{static void main(String[]a){for(var s=%c%s%1$c;;)System.out.println(s.format(s,34,s));}}";
                                //   Unformatted source code
        ;)                      //   Loop indefinitely
       System.out.println(      //    Print with trailing new-line:
         s.format(s,34,s));}}   //     The formatted source code

quine -part：

• 字符串s包含未格式化的源代码。
• %s用于将String本身输入s.format(...)。
• %c，%1$c以及34用于格式化双引号。
• s.format(s,34,s) 放在一起

挑战部分：

• for(;;) 用于无限循环。
• System.out.println(...) 用于打印尾随换行符

时髦的，29个字节

f=@print`f=[f]for)f()`for)f()

在线尝试！

RProgN 2，7个字节

«]³]]p:

在线尝试！

果冻，14字节

“;@ṾṄṛ¢”;@ṾṄṛ¢

在线尝试！

Pyth，11个字节

#jN B"#jN B

在这里尝试！

Brachylog，16个字节

∋"∋~kgjẉ₁⊥"gjẉ₁⊥

您不能完全在线上尝试它，但是我已经验证了它可以在我的安装中使用。

Brachylog，18个字节

∋"∋~kgjw₁⊥~n"gjw₁⊥

在线尝试！

从替代版本的改编本奎因，用劈我最初设计为回溯BOGO排序的所有东西。~n之所以要花两个字节，是因为ẉ（用尾随换行符打印的通常方法）在TIO上的字符编码遇到了一些奇怪的问题，并且插入到字符串文字中的实际换行符通过~kas 打印\n。

               w      Print
 "∋~kgjw₁⊥~n"         "∋~kgjw₁⊥~n"
∋                     which is an element of
                      the (unused and unconstrained) input
                ₁     formatted
          ~n          (so that the ~n is replaced with a newline)
             gj       with itself
   ~k                 (so that the ~k is replaced with the string in quotes),
                 ⊥    then try again.

因为w₁将输入作为列表[string to be formatted, formatting arguments]，所以将字符串包装在列表中，g然后将其与自身连接起来，j可以对其进行自身格式化。而且由于没有给程序提供任何输入，因此在程序开始时隐式存在的输入变量可以采用任何值，因此可以将其限制为包含"∋~kgjw₁⊥~n"作为元素的无数个列表之一，从而创建一个打印源程序击中时返回的选择点⊥。

Python 3.6，48 个 43字节。

-5个字节，感谢@Jo King

x='while 1:print("x=%r;exec(x)"%x)';exec(x)

Gol> <>，10个字节

"r2sslRoao

在线尝试！

这可能可以打更多