Ein Quine auf jeder Linie

30

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.
  • - Kürzester Code gewinnt!
mbomb007
quelle
Der Titel scheint nur einzeilige Programme zu qualifizieren?
Paŭlo Ebermann
@ PaŭloEbermann Dann lies die Problembeschreibung. Es ist ein witziger Titel, weil er sich reimt. Hier ist ein Beispiel eines gültigen mehrzeiligen Programms: codegolf.stackexchange.com/a/57985/34718 . Sie können nicht erwarten, alles über eine Herausforderung zu wissen, indem Sie nur den Titel lesen.
mbomb007
@ PaŭloEbermann Es ist einfach while(1)println(your_code);
Matthew Roh

Antworten:

19

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'!+!
Martin Ender
quelle
9

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

Sp3000
quelle
Eine Alternative ist "ar00go50l2)?.[, richtig?
mbomb007
3
@ mbomb007 Ich schätze, aber ich bevorzuge, d3*da gliest Ihr eigenen Quellcode
Sp3000
8

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.

Martin Ender
quelle
7

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
Feersum
quelle
Sprengt das nicht den Stapel?
Jesan Fafon,
1
@JesanFafon Nein, wenn du es probiert hättest, würdest du sehen, dass es nicht so ist. Es gibt keine Rekursion.
Feersum
6

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

ThisSuitIsBlackNot
quelle
Schön und danke für die Anerkennung. :-) Das originale Quine ist mein eigenes Design, obwohl es vielleicht schon jemand anderes entdeckt hat. Übrigens, $_=q{say"\$_=q{$_};eval"while 1};evaloder $_=q{{say"\$_=q{$_};eval";redo}};evalwäre ein paar Bytes kürzer. ( $_=q{say"\$_=q{$_};eval";eval};evalwäre noch kürzer, aber ich vermute, es wird irgendwann aus dem Stapel laufen.)
Ilmari Karonen
Ich hatte gehofft, dass du auftauchst! Vielen Dank für die kürzeren Lösungen. Ich dachte mir, Sie würden sich etwas Besseres einfallen lassen. Aber ich war so überwältigt, als ich es in der Antwort sah, die ich verlinkt habe. Ich musste es einfach selbst versuchen. :) Um ehrlich zu sein, habe ich meinen Kopf noch nicht ganz um Quines gewickelt, aber die zusätzlichen Antworten geben mir mehr zu sehen. Ich war mir nicht sicher, ob Sie das gemacht haben, weil ich gesehen habe, dass Ihnen die kürzeste nicht betrügerische Perl-Quine aller Zeiten (?!) auf dieser Seite gutgeschrieben wurde , aber es gibt keine Zuschreibung für diese Quine (mit printanstelle von say).
ThisSuitIsBlackNot
Übrigens, der letzte hat tatsächlich einen Segfehler, nachdem er eine Weile gelaufen ist. Nochmals vielen Dank, @Ilmari!
ThisSuitIsBlackNot
Eigentlich nehme ich das etwas zurück - ich bin definitiv nicht der erste, der dieses Quine erfunden hat , und da ich es definitiv schon einmal gesehen habe (ich habe das veröffentlicht, für das ich etwas Anerkennung beanspruche ), ist es ziemlich wahrscheinlich dass ich mich unbewusst an diesen Thread oder an einen anderen erinnert habe.
Ilmari Karonen
Okay, ich habe den Ursprung nicht spezifiziert. Unabhängig davon, danke für die 3 Bytes und danke für die ursprüngliche Inspiration.
ThisSuitIsBlackNot
5

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.

mbomb007
quelle
Du meinst, es muss sein \r?
Ismael Miguel
@IsmaelMiguel No. \nist eine neue Zeile und der ASCII-Code 10, sodass ein Hex-Dump des Quellcodes den Wert 0Afür dieses Byte haben würde. code.cside.com/3rdpage/us/newLine.html
mbomb007
1
@IsmaelMiguel Nicht wahr. Wenn Sie Code eingeben, drücken Sie tatsächlich die Eingabetaste für eine neue Zeile. \nZählt im Allgemeinen als 2 Zeichen und 2 Byte in Ihrem Code. Ich habe es aus Gründen der Lesbarkeit so geschrieben, da die Formatierung nicht gut funktioniert, um eine leere Zeile am Ende meines Quellcodes anzuzeigen. Und so musste ich angeben, dass es EIN Byte war, nicht zwei.
mbomb007
2
\nist immer ein einzelnes Zeichen, das als Zeilenvorschub bezeichnet wird . Eine Newline ist jedoch eine plattformabhängige Folge von Bytes.
Dennis
2
@ Tennis Vielleicht ja, aber es ist mir egal. Ich nenne /keinen "Solidus" und kenne niemanden, der das tut. "Newline" beginnt mit einem n, und das ist das Escape-Zeichen, so nenne ich es. Es ist näher an "Zeilenvorschub" als an "Wagenrücklauf".
mbomb007
3

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.

AdmBorkBork
quelle
3

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~*^
MickyT
quelle
1
@ mbomb007 Die Ausgabe pro Iteration sind die beiden Zeilen des Programms. Ich habe es hier
MickyT
3

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.

Kevin W.
quelle
Sie können eine get-Anweisung verwenden, um eine Leerstelle zu erfassen und ihr 2 für ein Byte hinzuzufügen, das kürzer ist als 98+2/: <, + 55, + 2g1_ #!, #: <"
MildlyMilquetoast
Und schieben Sie das Zitat und die Newline zuerst und kehren Sie den Drucker um,-1g0:+5<>:#,_1"
Jo King
2

K, 30 Bytes

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

R, 34 Bytes

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

So rufen Sie von der Befehlszeile aus auf:

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

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

mbomb007
quelle
"ar00gc0.0+feooooooooooooooo|ist zwei Bytes kürzer.
Cole
@Cole Danke. Ich hatte über den Spiegel nachgedacht, aber vergessen, ihn zu ändern, nachdem ich mich einer anderen Herausforderung gestellt hatte.
mbomb007
20 Bytes
Jo King
@JoKing Es gibt bereits eine kürzere> <> Lösung .
mbomb007
2

Python 2, 48 Bytes

c='c=\'%s\';while 1:print c%c';while 1:print c%c
DerInitializer
quelle
2

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.

Ilmari Karonen
quelle
1

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.

RK.
quelle
1

Javascript (ES6), 64

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

Alternativ (auch 64)

a="for(;;)console.log(`a=${JSON.stringify(a)};eval(a)`)";eval(a)
DankMemes
quelle
Würde die Alternative nicht einen Stapelüberlauf verursachen?
Patrick Roberts
Nein, es gibt keine Rekursion. Es sollte also nichts auf dem Stapel stehen.
DankMemes
Okay, ich habe gerade beide getestet, Sie haben Recht mit der alternativen Lösung, aber Ihre erste Lösung schlägt fehl und ich habe herausgefunden, warum. In der MDN-Dokumentation zu Pfeilfunktionen heißt es , dass "Pfeilfunktionen ein Argumentobjekt nicht ihrem Code aussetzen", damit arguments.calleees nicht existiert und ein Fehler ausgegeben wird.
Patrick Roberts
Interessant. Für mich in Firefox Developer Edition 42.0a2 (13.09.2015) funktionieren beide. Ich denke, sobald der Standard vollständig übernommen ist, wird der erste nicht mehr funktionieren.
DankMemes
Ich habe sie auf neuestem Chrom getestet, da ich versucht habe, Ihre erste Lösung mit !Klammern zu vergleichen und die Funktionsausführung nach der for-Schleife zu setzen, um die Notwendigkeit des Semikolon-Körpers for-Schleife zu vermeiden, der (glaube ich) 4 Bytes sparen würde
Patrick Roberts
1

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.

SuperJedi224
quelle
1

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
Ruslan
quelle
2
Ich werde es zulassen, da es nicht das kürzeste ist und kreativ und einzigartig. Und es hat nicht den Quellcode gelesen, sondern sich selbst ausgeführt.
mbomb007
1
Da der Dateiname nicht beliebig ist, sollten Sie zumindest den Dateinamen zur Byteanzahl hinzufügen.
Martin Ender
1
Ich glaube, du könntest es gebrauchen, echo on&&%0obwohl ich Angst habe, es zu versuchen.
DankMemes
1
Update: echo on&&%0funktioniert nicht. %0wird in der Ausgabe als erweitert angezeigt und Windows (7, 32 Bit, ausgeführt in einer VM) beendet das Ganze ziemlich schnell.
DankMemes
1
Ich denke, Sie können den .batTeil weglassen
SuperJedi224
1

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

Paŭlo Ebermann
quelle
1

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)}
Sinusoid
quelle
1

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

-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
Kevin Cruijssen
quelle
1

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 .

Nicht verwandte Zeichenfolge
quelle
1

Python 3.6, 48 43 Bytes.

-5 Bytes dank @Jo King

x='while 1:print("x=%r;exec(x)"%x)';exec(x)
Divy
quelle
Sie können verwenden %r, um zu sparen, dass diese 's ausgeblendet werden. 43 Bytes
Jo King
Das ergibt 41 für Python 3.8: P
Nur ASCII