Ваша мета - створити програму, яка друкує себе нескінченно, з новим рядком після кожного. Таким чином, якщо ваша програма є однолінійною, вона повторюватиметься в кожному рядку виводу.

Приклад

Програма:

A

Вихід:

A
A
A
...

Правила

• Це повинна бути повна програма, а не фрагмент чи функція.
• Програма повинна циклічно фіксуватись без помилок переповнення стека чи обмежень рекурсії.
• Вихід - це stdout або найближча альтернатива.
• Вхід програми не приймається.
• Стандартні лазівки заборонені, наприклад, відкриття файлу програми або доступ до зовнішнього ресурсу. Порожні програми заборонені як стандартна лазівка.
• Якщо ваш програмний код закінчується останнім рядком, це не вважається необхідним новим рядком між лайками, і ви повинні надрукувати інший.
• codegolf - Найкоротший код виграє!

Ділення, 7 байт

'!+!NR"

Досить проста модифікація найкоротшої квітки Fission, яку я знайшов до цього часу : я просто використовую неруйнівний, !а не 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 квітка, яка не закінчується _~.

{_o"_g
"o1}

Це просто штовхає блок. _gдублює блок і виконує його неодноразово, в той час як верхня частина стека є правдою (відхиляючи умову).

Тепер всередині блоку інша копія блоку все ще знаходиться на стеці. Ми копіюємо і друкуємо його, _oа потім друкуємо, _gа потім новий рядок (необхідний додатковий новий рядок між лайками) з "_g\n"o. Нарешті, ми натискаємо 1на стек, щоб цикл повторився, тому що, на жаль, блоки не є truthy (або хибними) у CJam.

Пітон 2, 39

Не дуже цікаве завдання в Python, оскільки тривіально додати цикл while до звичайної лайки.

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

Дякую Ілмарі Каронен за бриття 3-х байт від мого оригінального рішення, яке було:

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

Це, а також більш короткі 37-байтові рішення, наведені вище, - це все прості варіанти наступної лайки, яку я вперше побачив в одному з інших публікацій Ілмарі :

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

Оскільки все, що я додав у своєму оригінальному рішенні, було whileциклом, він дійсно заслуговує на більшу частину заслуг. :-)

Self-modifying Brainf*** (SMBF), 14 bytes

The trailing newline \n needs to be a literal, Unix, newline (ASCII code 10).

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

Explanation:

The code moves the pointer to the far left of its source code, then prints it all, including the newline (twice b/c of the rule). The loop continues.

PowerShell, 143 Bytes

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

Based off the Rosetta Code PowerShell quine, I'm pretty confident this isn't the shortest possible. String replacement formatting in PowerShell is icky for this, because the same delimiters for where to put the replacements {} also delimit code blocks while{}, so we have to use [char] casting, which bloats the code a bunch.

Underload, 25 bytes

First time I've tried something like this and I'm not sure if follows all the rules as it is a couple of lines. The newline was a bit of a pain.

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

Befunge, 30 20 bytes

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

A variation of a popular befunge quine that prints out a newline and pops -1 on the stack if it finishes the line.
Unfortunately, Befunge gets verbose when doing things in one line. I tried to remove all of the launchpads (#) that i could, but some had to be left in to skip certain commands (like ,).

Changes:

30-20 -> changed the base quine to a custom one I made that uses string input. This way, the branching is a lot easier.

Old:

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

I don't think this is optimal, but it's acceptable for now.

K, 30 bytes

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

R, 34 bytes

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

to invoke from the command line as follows:

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

><>, 31 29 bytes

A simple modification of the traditional ><> quine.

"ar00gc0.0+efooooooooooooooo|

To run, paste it here, click 'Submit', then 'Start' (running without animation doesn't work). Feel free to increase the execution speed.

Python 2, 48 bytes

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

GolfScript, 16 bytes

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

This ended up looking a lot like Martin Büttner's CJam entry. An interesting feature is that, as it turns out, the shortest way to append ".do" to the block when it's printed is to assign it to the line terminator n. (Of course, we also need to include an actual newline in the string, to replace the one n normally contains.) The same string (being truthy in GolfScript) is also left on the stack for the do loop to pop off, ensuring that the loop runs forever.

BASH, 76 bytes

Just couldn't resist, especially with PowerShell here :)

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

The whitespace is important for an EXACT copy.

Javascript (ES6), 64

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

Alternatively (also 64)

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

Microscript, 22 bytes

"f1{CqxCanx"f1{CqxCanx

Based on the quine from the Esolangs article: "fCqxah"fCqxah. Exploits the fact that the language autoappends closing braces as needed, without which this would be two bytes longer.

Batch, 10 (+ 4 for filename length)

Not sure if this qualifies for two reasons:

• Technically, there may or may not be textual side effects from the Windows command shell, as that depends on how it is configured.
• This program invokes itself by name, and I am not sure whether that's prohibited by the rules (specifically the "no opening of program file" rule). It is not opening itself for the purposes of reading and printing out the text; it is simply re-running itself. Further, the file system structure is an integral part of old-school batch scripts (oftentimes even being used to store program state, etc). As such, I am not sure whether this violates the 5th rule or not.

The code (for a program named q.bat):

echo on&&q

Ceylon, 210 208 bytes

Of course this won't win anything...

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

Original:

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

I modified my Quine from two days ago by adding the while(true){...} loop, so I come from the 185 bytes of the plain Quine to 210 (I don't need the trailing new line character anymore). But then I found that a while(1<2){...} loop is even two bytes shorter:

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

(Ceylon has no for(;;) loop like Java, and the braces are also needed for this loop.)

PowerShell, 132 107 Bytes

$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}

Based off of the Rosetta Quine (Same as @AdmBorkBork) although doesn't use formatting for string replacement... maybe switching to a for loop and using formatting would be best?

I'm sure if AdmBorkBork came back they would beat this by a lot :P

EDIT Figured out the for loop and replacements, all thanks to my predecessor :)

Old attempt:

$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 bytes

A modification of one of the Ruby quines found here.

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

Java 10, 194 bytes

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

Explanation:

Try it online (times out after 60 sec).

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:

• The String s contains the unformatted source code.
• %s is used to input this String into itself with the s.format(...).
• %c, %1$c and the 34 are used to format the double-quotes.
• s.format(s,34,s) puts it all together

Challenge part:

• for(;;) is used to loop indefinitely.
• System.out.println(...) is used to print with trailing new-line

Funky, 29 bytes

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

Try it online!

RProgN 2, 7 bytes

«]³]]p:

Try it online!

Jelly, 14 bytes

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

Try it online!

Pyth, 11 bytes

#jN B"#jN B

Try it here!

Brachylog, 16 bytes

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

You can't quite try it online, but I have verified that it works on my installation.

Brachylog, 18 bytes

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

Try it online!

Adapted from the alternate version of this quine, with a backtracking hack I had initially devised for bogosort of all things. Spends two bytes on ~n because ẉ (the usual means for printing with a trailing newline) hits some odd issues with character encoding on TIO, and an actual newline inserted into the string literal gets printed through ~k as \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.

Since w₁ takes input as a list [string to be formatted, formatting arguments], wrapping a string in a list with g then concatenating it to itself with j allows it to be formatted with itself. And since no input is given to the program, the input variable which is implicitly present at the beginning of the program can take on any value, so it can be constrained to one of the infinitely many lists which contain "∋~kgjw₁⊥~n" as an element, creating a single choice point to be backtracked to when after printing its source the program hits ⊥.

Python 3.6, 48 43 bytes.

-5 bytes thanks to @Jo King

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

Gol><>, 10 bytes

"r2sslRoao

Try it online!

This can probably be golfed down more