Ihr Ziel ist es, ein Programm zu erstellen, das sich auf unbestimmte Zeit mit jeweils einer neuen Zeile ausgibt. Wenn Ihr Programm also ein Einzeiler ist, wird es in jeder Zeile der Ausgabe wiederholt.

Beispiel

Programm:

A

Ausgabe:

A
A
A
...

Regeln

• Es muss ein vollständiges Programm sein, kein Snippet oder eine Funktion.
• Das Programm sollte eine Endlosschleife ohne Fehler durch Stapelüberlauf oder Rekursionslimit ausführen.
• Die Ausgabe erfolgt nach Standard oder nach der nächstgelegenen Alternative.
• Es werden keine Programmeingaben akzeptiert.
• Standardlücken sind nicht zulässig, z. B. das Öffnen der Programmdatei oder der Zugriff auf eine externe Ressource. Leere Programme sind als Standard-Regelungslücke nicht zulässig.
• Wenn Ihr Programmcode mit einem nachgestellten Zeilenumbruch endet, zählt dies nicht als der erforderliche Zeilenumbruch zwischen den Zeilenumbrüchen, und Sie müssen einen anderen drucken.
• codegolf - Kürzester Code gewinnt!

Spaltung, 7 Bytes

'!+!NR"

Eine ziemlich einfache Modifikation der kürzesten Fission quine, die ich bisher gefunden habe : Ich verwende einfach die zerstörungsfreie !anstelle von Ound Nfüge eine for newline hinzu.

Alles in allem funktioniert es also so: Der Kontrollfluss beginnt Rmit einem rechtsgerichteten Atom. "Schaltet den String-Modus um, was bedeutet, dass alles "gedruckt wird, bis das nächste gedruckt wird: in diesem Fall '!+!NR. Damit bleibt die "und die neue Zeile zu drucken. '!Setzt die Masse des Atoms auf 33, +erhöht sie auf 34 (den Zeichencode von ") und gibt !das Zitat aus. Ndruckt eine neue Zeile und Rist in diesem Fall jetzt ein No-Op, so dass die Schleife von vorne beginnt.

Die folgende 7-Byte-Lösung funktioniert auch:

"NR'!+!

> <> , 16 Bytes

'ard3*o50l2)?.~~

Das traditionelle> <> Quine verwendet zu viele os, daher verwenden wir eine Schleife zum Drucken. Vor jedem Sprung drücken wir 5 und 0 (die Koordinaten, zu denen gesprungen werden soll). Danach springen wir entweder mit, .wenn noch etwas zu drucken ist, oder geben die beiden oberen Werte mit ein ~~.

(Zurückgesetzt auf die 16-Version, da ich die Stapelüberlaufregel vergessen habe.)

CJam, 13 Bytes

{_o"_g
"o1}_g

Der Online-Interpreter druckt nichts, bevor das Programm beendet wird. Sie müssen dies daher im Java-Interpreter testen.

Erläuterung

Endlich eine verallgemeinerte CJam-Quine, die nicht endet _~.

{_o"_g
"o1}

Dies schiebt einfach einen Block. _gdupliziert den Block und führt ihn wiederholt aus, während der oberste Teil des Stapels wahr ist (Verwerfen der Bedingung).

Jetzt im Block befindet sich die andere Kopie des Blocks noch auf dem Stapel. Wir duplizieren und drucken es mit _ound drucken dann _ggefolgt von einem Zeilenumbruch (dem erforderlichen zusätzlichen Zeilenumbruch zwischen Quines) mit "_g\n"o. Schließlich schieben wir ein 1auf den Stack, damit die Schleife wiederholt wird, da Blöcke in CJam leider nicht wahr (oder falsch) sind.

Python 2, 39

Keine sehr interessante Aufgabe in Python, da es trivial ist, die while-Schleife zu einem normalen Quine hinzuzufügen.

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

Perl 5.10+, 40 37 Bytes

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

oder (auch 37 Bytes)

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

Rufen Sie mit dem Kommandozeilen-Flag -M5.010oder auf -E, z

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

Vielen Dank an Ilmari Karonen für das Abschneiden von 3 Bytes meiner ursprünglichen Lösung, die lautete:

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

Dies sowie die kürzeren 37-Byte-Lösungen oben sind alles einfache Variationen des folgenden Quine, den ich zum ersten Mal in einem der anderen Beiträge von Ilmari gesehen habe :

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

Da alles, was ich in meiner ursprünglichen Lösung hinzugefügt habe, eine whileSchleife war, verdient er wirklich den größten Teil des Kredits. :-)

Selbstmodifizierendes Brainf *** (SMBF) , 14 Byte

Die nachfolgende Newline \nmuss ein Literal, Unix, Newline (ASCII-Code 10) sein.

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

Erläuterung:

Der Code verschiebt den Zeiger ganz links von seinem Quellcode und druckt dann alles aus, einschließlich der neuen Zeile (zweimal in umgekehrter Reihenfolge der Regel). Die Schleife geht weiter.

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

Basierend auf dem Rosetta Code PowerShell Quine bin ich ziemlich sicher, dass dies nicht der kürzeste Weg ist. Das Formatieren von Zeichenfolgenersetzungen in PowerShell ist schwierig, da dieselben Begrenzungszeichen für die Position der Ersetzungen {}auch Codeblöcke begrenzen. Daher while{}müssen wir [char]Casting verwenden, das den Code ein wenig aufbläht.

Unterlast, 25 Bytes

Zum ersten Mal habe ich so etwas ausprobiert und bin mir nicht sicher, ob ich alle Regeln befolge, da es sich um ein paar Zeilen handelt. Die Newline war ein bisschen schmerzhaft.

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

Befunge , 30 20 Bytes

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

Eine Variation einer beliebten befunge quine, die eine neue Zeile ausgibt und -1 auf dem Stapel anzeigt, wenn sie die Zeile beendet.
Leider wird Befunge wortreich, wenn er Dinge in einer Zeile tut. Ich habe versucht, alle Launchpads ( #) zu entfernen , die ich konnte, aber einige mussten belassen werden, um bestimmte Befehle (wie ,) zu überspringen .

Änderungen:

30-20 -> habe das Basis-Quine in ein benutzerdefiniertes geändert, das Zeichenketteneingabe verwendet. Auf diese Weise wird die Verzweigung wesentlich erleichtert.

Alt:

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

Ich denke nicht, dass dies optimal ist, aber es ist vorerst akzeptabel.

K, 30 Bytes

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

R, 34 Bytes

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

So rufen Sie von der Befehlszeile aus auf:

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

> <> 31 29 Bytes

Eine einfache Modifikation des traditionellen > <> Quine .

"ar00gc0.0+efooooooooooooooo|

Um es auszuführen, fügen Sie es hier ein , klicken Sie auf "Senden" und dann auf "Starten" (ohne Animation auszuführen, funktioniert nicht). Fühlen Sie sich frei, um die Ausführungsgeschwindigkeit zu erhöhen.

Python 2, 48 Bytes

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

GolfScript, 16 Bytes

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

Am Ende sah das sehr nach Martin Büttners CJam-Eintrag aus . Ein interessantes Merkmal ist, dass, wie sich herausstellt, der kürzeste Weg, ".do"an den Block anzuhängen , wenn er gedruckt wird, darin besteht, ihn dem Zeilenabschluss zuzuweisen n. (Natürlich müssen wir auch eine tatsächliche neue Zeile in die Zeichenfolge einfügen, um die nnormalerweise enthaltene zu ersetzen .) Die gleiche Zeichenfolge (die in GolfScript der Wahrheit entspricht) verbleibt auch auf dem Stapel, damit die doSchleife abspringt, um sicherzustellen, dass die Schleife abläuft läuft für immer.

BASH, 76 Bytes

Ich konnte einfach nicht widerstehen, besonders mit PowerShell hier :)

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

Das Leerzeichen ist wichtig für eine EXAKTE Kopie.

Javascript (ES6), 64

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

Alternativ (auch 64)

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

Mikroskript , 22 Bytes

"f1{CqxCanx"f1{CqxCanx

Basierend auf dem quine aus dem Esolangs Artikel: "fCqxah"fCqxah. Nutzt die Tatsache aus, dass die Sprache nach Bedarf automatisch schließende geschweifte Klammern anfügt, ohne die dies zwei Bytes länger wäre.

Batch, 10 (+ 4 für Dateinamenlänge)

Ich bin mir nicht sicher, ob dies zwei Gründe hat:

• Technisch gesehen kann die Windows-Befehlsshell Textnebeneffekte aufweisen oder nicht, da dies von der Konfiguration abhängt.
• Dieses Programm ruft sich selbst mit seinem Namen auf, und ich bin nicht sicher, ob dies durch die Regeln (insbesondere die Regel "Kein Öffnen der Programmdatei") verboten ist. Es öffnet sich nicht zum Lesen und Ausdrucken des Textes; es läuft einfach von selbst wieder. Darüber hinaus ist die Dateisystemstruktur ein integraler Bestandteil von Batch-Skripten der alten Schule (die häufig sogar zum Speichern des Programmstatus usw. verwendet werden). Daher bin ich mir nicht sicher, ob dies gegen die 5. Regel verstößt oder nicht.

Der Code (für ein Programm mit dem Namen q.bat):

echo on&&q

Ceylon , 210 bis 208 Bytes

Natürlich wird das nichts gewinnen ...

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

Ich habe meinen Quine von vor zwei Tagen durch Hinzufügen der while(true){...}Schleife geändert , sodass ich von den 185 Bytes des einfachen Quine auf 210 komme (ich brauche das abschließende neue Zeilenzeichen nicht mehr). Aber dann fand ich, dass awhile(1<2){...} Schleife sogar zwei Bytes kürzer ist:

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 hat keine for(;;)Schleife wie Java, und die geschweiften Klammern werden auch für diese Schleife benötigt.)

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}

Basierend auf dem Rosetta Quine (wie @AdmBorkBork), obwohl keine Formatierung für das Ersetzen von Zeichenfolgen verwendet wird. Wäre es am besten, auf eine for-Schleife zu wechseln und die Formatierung zu verwenden?

Ich bin mir sicher, wenn AdmBorkBork zurückkehren würde, würden sie dies um einiges übertreffen: P

EDIT Hat die for-Schleife und die Ersetzungen herausgefunden, alles dank meinem Vorgänger :)

Alter Versuch:

$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

Eine Modifikation einer der hier gefundenen Ruby-Quines .

_="_=%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));}}

Erläuterung:

Probieren Sie es online aus (Timeout nach 60 Sekunden).

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 -Teil:

• Der String senthält den unformatierten Quellcode.
• %swird verwendet, um diesen String in sich selbst mit dem einzugeben s.format(...).
• %c, %1$cUnd die 34werden verwendet , um die doppelten Anführungszeichen zu formatieren.
• s.format(s,34,s) setzt alles zusammen

Herausforderungsteil:

• for(;;) wird verwendet, um eine Endlosschleife auszuführen.
• System.out.println(...) wird verwendet, um mit einer nachgestellten neuen Zeile zu drucken

Funky , 29 Bytes

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

Probieren Sie es online!

RProgN 2 , 7 Bytes

«]³]]p:

Probieren Sie es online!

Jelly , 14 Bytes

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

Probieren Sie es online!

Pyth, 11 Bytes

#jN B"#jN B

Probieren Sie es hier aus!

Brachylog , 16 Bytes

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

Sie können es nicht ganz online ausprobieren , aber ich habe überprüft, dass es in meiner Installation funktioniert.

Brachylog , 18 Bytes

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

Probieren Sie es online!

Angepasst an die alternative Version dieses Quines , mit einem Backtracking-Hack, den ich ursprünglich für alles Mögliche entwickelt hatte . Verbraucht zwei Bytes, ~nda ẉ(die übliche Methode zum Drucken mit einer nachgestellten Zeile) bei der Zeichencodierung in TIO einige ungewöhnliche Probleme auftreten und eine tatsächliche Zeile, die in das Zeichenfolgenliteral eingefügt wird, durchgedruckt wird ~kals\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.

Da w₁Eingaben als Liste verwendet werden [string to be formatted, formatting arguments], können Sie eine Zeichenfolge in eine Liste geinschließen und sie dann mit sich selbst jverknüpfen, um sie mit sich selbst zu formatieren. Und da dem Programm keine Eingabe gegeben wird, kann die zu Beginn des Programms implizit vorhandene Eingabevariable einen beliebigen Wert annehmen, sodass sie auf eine der unendlich vielen Listen beschränkt werden kann, die "∋~kgjw₁⊥~n"als Element eine einzige Liste enthalten Auswahlpunkt, zu dem zurückverfolgt werden soll, wenn das Programm nach dem Drucken der Quelle einen Treffer erzielt ⊥.

Python 3.6, 48 43 Bytes.

-5 Bytes dank @Jo King

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

Gol> <> , 10 Bytes

"r2sslRoao

Probieren Sie es online!

Dies kann wahrscheinlich mehr Golf gespielt werden