Votre objectif est de créer un programme qui s'imprime indéfiniment, avec une nouvelle ligne après chacun. Ainsi, si votre programme est à une ligne, il sera répété sur chaque ligne de la sortie.

Exemple

Programme:

A

Sortie:

A
A
A
...

Règles

• Il doit s'agir d'un programme complet, et non d'un extrait ou d'une fonction.
• Le programme devrait boucler indéfiniment sans erreurs de dépassement de pile ou de limite de récursivité.
• La sortie est vers stdout ou l'alternative la plus proche.
• Aucune entrée de programme n'est acceptée.
• Les failles standard sont interdites, telles que l'ouverture du fichier du programme ou l'accès à une ressource externe. Les programmes vides sont interdits comme échappatoire standard.
• Si votre code de programme se termine par une nouvelle ligne de fin, cela ne compte pas comme la nouvelle ligne nécessaire entre les quines et vous devez en imprimer une autre.
• codegolf - Le code le plus court gagne!

Fission, 7 octets

'!+!NR"

Une modification assez simple du quine de Fission le plus court que j'ai trouvé jusqu'à présent : j'utilise simplement le non destructif !au lieu de Oet j'ai ajouté un Npour la nouvelle ligne.

Donc, dans l'ensemble, voici comment cela fonctionne: le flux de contrôle commence à la Ravec un atome de droite. "bascule le mode chaîne, ce qui signifie tout jusqu'à ce que le suivant "soit imprimé: dans ce cas '!+!NR. Cela laisse le "et la nouvelle ligne à imprimer. '!définit la masse de l'atome à 33, l' +incrémente à 34 (le code de caractère de ") et !imprime la citation. Nimprime une nouvelle ligne, et Rest maintenant un no-op dans ce cas, donc la boucle recommence.

La solution 7 octets suivante fonctionne également:

"NR'!+!

> <> , 16 octets

'ard3*o50l2)?.~~

La quine traditionnelle <<> utilise trop de os, nous utilisons donc une boucle pour l'impression. Avant chaque saut, nous poussons 5 et 0 (les coordonnées de l'endroit où sauter), après quoi nous sautons avec. s'il y a encore quelque chose à imprimer, ou nous sautons les deux premières valeurs avec ~~.

(Revenu à la version 16 depuis que j'ai oublié la règle de débordement de pile.)

CJam, 13 octets

{_o"_g
"o1}_g

L'interpréteur en ligne n'imprime rien avant la fin du programme, vous devrez donc le tester dans l'interpréteur Java.

Explication

Enfin une quine CJam généralisée qui ne se termine pas _~.

{_o"_g
"o1}

Cela pousse simplement un bloc. _gduplique le bloc et l'exécute de façon répétée tandis que le haut de la pile est véridique (rejetant la condition).

Maintenant à l'intérieur du bloc, l'autre copie du bloc est toujours sur la pile. Nous le dupliquons et l'imprimons avec _opuis nous imprimons _gsuivi d'une nouvelle ligne (la nouvelle ligne supplémentaire requise entre les quines) avec "_g\n"o. Enfin, nous poussons un 1sur la pile pour que la boucle se répète, car malheureusement, les blocs ne sont pas vrais (ou faux) dans CJam.

Python 2, 39

Pas une tâche très intéressante en Python car il est trivial d'ajouter la boucle while à un quine normal.

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

Perl 5.10+, 40 37 octets

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

ou (également 37 octets)

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

Appelez avec le drapeau de ligne de commande -M5.010ou -E, par exemple

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

Merci à Ilmari Karonen avoir rasé 3 octets de ma solution d'origine, qui était:

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

Ceci, ainsi que les solutions plus courtes de 37 octets ci-dessus, sont toutes de simples variations du quine suivant, que j'ai vu pour la première fois dans l'un des autres articles d' Ilmari :

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

Comme tout ce que j'ai ajouté dans ma solution d'origine était une whileboucle, il mérite vraiment la plupart du crédit. :-)

Brainf auto-modifiable *** (SMBF) , 14 octets

La nouvelle ligne de fin \ndoit être une nouvelle ligne littérale, Unix (code ASCII 10).

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

Explication:

Le code déplace le pointeur à l'extrême gauche de son code source, puis imprime tout, y compris la nouvelle ligne (deux fois b / c de la règle). La boucle continue.

PowerShell, 143 octets

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

Basé sur le quine Rosetta Code PowerShell , je suis assez confiant que ce n'est pas le plus court possible. Le formatage de remplacement de chaîne dans PowerShell est compliqué pour cela, car les mêmes délimiteurs pour l'emplacement des remplacements {}délimitent également les blocs de code while{}, nous devons donc utiliser[char] conversion, qui gonfle le code un tas.

Sous-charge, 25 octets

La première fois, j'ai essayé quelque chose comme ça et je ne suis pas sûr de suivre toutes les règles car il s'agit de quelques lignes. La nouvelle ligne était un peu pénible.

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

Befunge , 30 20 octets

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

Une variante d'une quine befunge populaire qui imprime une nouvelle ligne et affiche -1 sur la pile si elle termine la ligne.
Malheureusement, Befunge devient verbeux lorsqu'il fait les choses sur une seule ligne. J'ai essayé de supprimer tous les launchpads ( #) que je pouvais, mais certains ont dû être laissés pour ignorer certaines commandes (comme ,).

Changements:

30-20 -> changé le quine de base en un personnalisé que j'ai fait qui utilise une entrée de chaîne. De cette façon, la ramification est beaucoup plus facile.

Vieux:

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

Je ne pense pas que ce soit optimal, mais c'est acceptable pour l'instant.

K, 30 octets

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

R, 34 octets

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

à appeler à partir de la ligne de commande comme suit:

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

> <>, 31 29 octets

Une simple modification du quine traditionnel > <> .

"ar00gc0.0+efooooooooooooooo|

Pour l'exécuter, collez-le ici , cliquez sur «Soumettre», puis sur «Démarrer» (l'exécution sans animation ne fonctionne pas). N'hésitez pas à augmenter la vitesse d'exécution.

Python 2, 48 octets

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

GolfScript, 16 octets

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

Cela a fini par ressembler beaucoup à l'entrée CJam de Martin Büttner . Une caractéristique intéressante est que, en fin de compte, le moyen le plus court pour ajouter ".do"au bloc lorsqu'il est imprimé est de l'attribuer au terminateur de ligne n. (Bien sûr, nous devons également inclure une nouvelle ligne dans la chaîne, pour remplacer celle nqui contient normalement.) La même chaîne (fidèle dans GolfScript) est également laissée sur la pile pour que la doboucle se détache, garantissant que la boucle fonctionne pour toujours.

BASH, 76 octets

Je n'ai tout simplement pas pu résister, surtout avec PowerShell ici :)

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

L'espace est important pour une copie EXACTE.

Javascript (ES6), 64

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

Alternativement (également 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