Schreiben Sie ein Programm (oder eine Funktion) (nennen wir es P1), das beim Ausführen ein anderes Programm P2 mit derselben Sprache ausgibt und genau 1 Byte länger als P1 ist.

Programm P2 sollte beim Ausführen ein drittes Programm P3 ausgeben, das 1 Byte länger als P2 ist. P3 muss ein Programm P4 ausgeben, das ein Byte länger ist als P3 usw. Dasselbe gilt für P5, P6, ..., P∞.

Die Programmkette sollte auf unbestimmte Zeit oder an einen Ort verlaufen, an dem der Interpreter nicht mehr damit umgehen kann (aber als theoretisch gültiges Programm in der Sprache bleiben muss).

Regeln

• Standardlücken verboten
• Alle Programme in der Kette sollten in einer Sprache sein
• Es wird keine Eingabe gemacht. Ausgang geht auf Standardausgang oder Funktionsrückgabewert
• Das Programm muss nach einer gewissen Zeit beendet sein. Ein Programm, das die Ausgabe nach einem bestimmten Zeitpunkt abbricht, aber niemals beendet wird, ist nicht qualifiziert

Das kürzeste Programm P1 in Bytes in jeder Sprache gewinnt!

JavaScript (ES6), 14 - 12 Byte

-2 Bytes dank @Shaggy

f=_=>"f=_"+f

Testschnipsel

s=`f=_=>"f=_"+f`;

for(i=10;i--;s=eval(s)())
  o.innerText+=s+"\n";

<pre id=o></pre>

7 , 4 Bytes ASCII

1603

Probieren Sie es online!

Ich weiß, dass 7 normalerweise nicht in ASCII codiert ist, aber diesmal ist es eine bequemere Codierung, sodass wir bei jedem Lauf 1 Byte hinzufügen, nicht 3 Bits.

Ich bin mir auch nicht sicher, ob dies als Betrug gilt oder nicht. (Es ist normalerweise unklar, ob eine 7-Quine betrügt oder nicht, da sie auf verschiedene Weise die Grenze überspannt.) Sie können ein anständiges Argument dafür vorbringen, dass die Zeichen 0codiert 6, aber im Allgemeinen ist unklar, woher die resultierenden Zeichen kommen "in 7, weil es so viele, ziemlich bizarre, implizite Verhaltensweisen hat.

Dieses Programm druckt sich selbst mit 1angehängten Zeichen und wird dies auch dann tun, wenn Sie eine Reihe von 1s daran anhängen . Hier ist ein kommentierter Debug-Trace von 160311:

|| 160311      Initial data ||; initial program 160311
||7 60311      1 command = append 7 to data
|1 0311        6 command = escape from the last | onwards (7 escapes to 1)
|16e77         0311 commands = append 6e77 to data
|16e77 16e77   Implicit (program is empty): copy data past last | to program
|16e777 6e77   1 command = append 7 to data
71603111 e77   6 command = escape from the last | onwards
71603111 e77   e7 command = output in same encoding as the source

(Es sind keine |mehr im Programm, daher ewird das Programm sofort als Nebeneffekt beendet, was bedeutet, dass das Finale 7niemals ausgeführt wird.)

Die grundlegende Verwirrung darüber, woher alle Zeichen kommen, besteht darin, dass die meisten Befehle in 7 beim Ausführen nur Daten erzeugen und dann 6versuchen, eine Folge von Befehlen zu rekonstruieren, die das gegebene Datenfragment erzeugen würden. Dies endet oft in der Nähe des Originals, ist jedoch nicht mit diesem identisch. (Zu Quining-Zwecken schreiben Sie normalerweise ein 7-Programm so, dass das Ergebnis fast gleich ist und sich normalerweise in führenden oder nachfolgenden Werten unterscheidet 7.) So wird beispielsweise das 1in den Daten 716, was der einfachste Weg zum Anhängen ist 1auf den aktuellen Datenstring. Wir haben es ursprünglich mit 16einer anderen (aber ähnlichen) Zeichenfolge produziert und dabei eines der Zeichen destruktiv entfernt|Marker, mit denen die Daten begonnen haben. (Ich denke, das beste Argument dafür, dass dies keine reine Quine ist, ist, dass sich die Ausgabe von der Eingabe unterscheidet!)

Haskell , 74 66 Bytes

BEARBEITEN:

• -2 Bytes von H.PWiz mit <>, dann -6 durch Verschieben der (10*)<$>.

Dies verwendet jetzt den neuen freien <>Operator ( SemigroupMultiplikation, erfordert GHC 8.4, um ohne Import zu arbeiten.)

main=putStr$fst<>show$(10*)<$>("main=putStr$fst<>show$(10*)<$>",1)

Probieren Sie es online! (Cheats mit einem Import, da TIO GHC 8.4 noch nicht hat.)

Wie es funktioniert

• main=putStr$ ist ein Boilerplate, um den folgenden String-Wert auszugeben.

• fst<>showist eine Funktion, die ein Tupel annimmt und eine Zeichenfolge zurückgibt, die aus dem ersten Element des Tupels besteht, das mit der Zeichenfolgendarstellung des Tupels verkettet ist. Dh

  (fst<>show)(s,t) = fst(s,t)<>show(s,t) = s++show(s,t)

• (10*)<$>multipliziert das letzte Element des folgenden Tupels mit 10 und fügt 0seiner Zeichenfolgendarstellung eine Ziffer hinzu .

C (GCC) , 134 132 Bytes

Leichte Überarbeitung der kanonischen C-Quine. Fürchterlich lang.

x;*s="x;*s=%c%s%c;main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}";main(i){for(i=__LINE__;i--;puts(&x));printf(s,34,s,34);}

Probieren Sie es online!

Spaltung 2 , 7 Bytes

'!+OR!"

Probieren Sie es online!

Das Standard-Fission-Quine , aber mit einem Extra !, das bei jeder Iteration ein zusätzliches 0x01 am Anfang des Codes ausgibt.

Pari / GP , 35 Bytes

(f=(x)->print1("(f="f")("1x")"))(1)

Probieren Sie es online!

Python 2 , 38 Bytes

s="print's=%r;exec s'%(s+'#')";exec s

Probieren Sie es online!

Brainfuck , 420 Bytes

->+++>>+++>+>++>+++>+>+>+++>>>>>>>>>>>>>>>>>>>>+>+>++>+++>++>>+++>+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>+>+>>+++>>+++>>>>>+++>+>>>>>>>>>++>+++>+++>+>>+++>+++>+>++>>+++>+>+++>+>++>+++>>>+>+>++>+++>+>+>>+++>>>>>>>+>+>>>+>+>++>+++>+++>+>>+++>>>+++>+>++>+++>++>>+>+>++>+++>+>+>>+++>>>>>+++>+>>>>>++>+++>+++>+>>+++>>>+++>+>+++>+>>+++>>+++>>++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++[[<++++++++++++++++>-]<+++++++++.<]>.

Probieren Sie es online!

Dies ist eine Modifikation der "normalen" BrainFuck-Quine , bei der .am Ende bei .jeder Iteration eine zusätzliche Note hinzukommt .

Das Quine selbst codiert Brainfuck-Zeichen als Stapel von Hexadezimalziffern: Insbesondere die Hexadezimalziffern von c-0x2b, die günstigerweise die folgenden sind:

+: 0x00
-: 0x02
[: 0x30
]: 0x32
<: 0x11
>: 0x13
,: 0x01
.: 0x03

Die Codierung deckt zwei Codefragmente ab: >++[[>>+[>]++>++[<]<-]>+[>]<+<+++[<]<+]>>->[>]++++>++Verschiebt die Codierung der Codierung selbst, [[<++++++++++++++++>-]<+++++++++.<]wandert über den Stapel und druckt alles.

Schmutzig , 9 Bytes

'"n[!]a!␛

Probieren Sie es online!

'   start and end a string literal
"   push a literal '
n   remove newlines
[!] print the string
a   push the alphabet
!   print the first character
␛   end the program

Wenn das Lesen von Quellcode erlaubt ist:

Schmutzig , 8 Bytes

Q[!]W33!

Probieren Sie es online!

Erklärt:

Q   push the source code
[!] print each character
W   clear the now-empty stack
33! print an exclaimation mark

Könnte gültig sein:

Schmutzig , 4 Bytes

Q[‼]

Probieren Sie es online!

Es druckt den Quellcode mit einer nachgestellten Newline.
(Und eine Reihe von Leerzeichen, aufgrund eines Fehlers. Ohne sie funktioniert es jedoch genauso.)

Beachten Sie, dass es nur im nativen Zeichensatz funktioniert und nicht, wenn Sie das UTF8-Front-End verwenden. Um es also mit TIO zu testen, müssen Sie das Zeichen ersetzen, das es zwischen den []s ausgibt. ‼Dies ist das UTF8-Äquivalent für das, was es druckt .

Java 8, 162 146 Bytes

v->{String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"+1;return s.format(s,34,s).replaceAll("1+$","");}

Probieren Sie es online aus.
Probieren Sie das erste Ausgabeprogramm aus . Probieren Sie das zweite Ausgabeprogramm aus . Versuchen Sie das dritte Ausgabeprogramm .

Erläuterung:

v->{                       // Method with empty unused parameter and String return-type
  String s="v->{String s=%c%s%1$c+1;return s.format(s,34,s).replaceAll(%1$c1+$%1$c,%1$c%1$c);}"
                           //  The unformatted source code
           +1;             //  Plus a random digit (1 in this case)
  return s.format(s,34,s)  //  Create the quine
          .replaceAll("1+$","");}
                           //  Then remove any trailing 1s

quine -Teil:

• Das 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:

• +1 Fügt dem unformatierten und dem formatierten Programm eine 1 hinzu.
• .replaceAll("1+$","");}: Da wir die Anzahl der Programmbytes nur um eins anstatt um zwei erhöhen möchten, entfernen wir alle nachfolgenden Einsen, bevor wir zurückkehren.

> <> 9 Bytes

#o<:}-1:"

Probieren Sie es online!

Variation über ein klassisches> <> Quine, das einfach einen weiteren Dupe-Befehl hinzufügt, um das #in der Front zu kopieren .

Perl 5 , 32 Bytes

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

Probieren Sie es online!

GolfScript , 9 Bytes

{'.~1'}.~

Probieren Sie es online!

CJam , 9 Bytes

{"_~1"}_~

Probieren Sie es online!

Ich schreibe diese beiden Lösungen in der gleichen Antwort, da sie nur geringfügige Variationen voneinander sind und auf genau die gleiche Weise funktionieren. Sie basieren beide auf dem gängigen GolfScript-Quine {'.~'}.~(oder {"_~"}_~in CJam), das zB in meiner vorherigen Antwort ausführlicher beschrieben wird .

Der einzige Unterschied besteht darin, dass diese Variante ein 1Byte an das Ende ihrer Ausgabe anfügt . Jeder String von 1s (oder ein anderes Integer-Literal ohne führende Nullen) ist in GolfScript und CJam selbst ein trivialer Quine, sodass alle bereits am Ende des obigen Codes vorhandenen einfach wörtlich in die Ausgabe kopiert werden. Da GolfScript (und CJam) Ganzzahlen beliebiger Länge verwenden, funktioniert dies für beliebig lange Programme, zumindest solange der Computer, auf dem der Code ausgeführt wird, über genügend Speicher verfügt, um ihn zu speichern.

Attache , 76 72 61 Bytes

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Probieren Sie es online!

Standard-Quine, die xnach jeder Iteration ein Leerzeichen am Ende von hinzufügt .

Erste Iterationen:

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]] ",Repr[x+sp]]

Print!Format[x:="Print!Format[x:=%s,Repr[x+sp]]  ",Repr[x+sp]]

usw.

Attache, 72 Bytes

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

Probieren Sie es online!

Dies ist einfach eine Variation des Standardformats quine mit einer Variablen y, die 10*ynach jeder Iteration festgelegt wird

Die ersten paar Iterationen:

y:=1Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=10Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

y:=100Print!Format[x:="y:=%sPrint!Format[x:=%s,y*10,Repr!x]",y*10,Repr!x]

usw.

Swift 4 , 89 Bytes

let(a,b)=(";print(\"let(a,b)=\\((a,b+\"-\"))\"+a)", "");print("let(a,b)=\((a,b+"-"))"+a)

Beinhaltet eine nachgestellte Newline

Probieren Sie es online!

Haskell , 88 Bytes

main=putStr$snd(span(<'m')s)++show s;s='#':"main=putStr$snd(span(<'m')s)++show s;s='#':"

Probieren Sie es online! Wächst, indem der Datenzeichenfolge vorangestellt wird #.

Stax , 20 bis 18 Bytes

"34s+cTZL"34s+cTZL

Führen Sie es aus und debuggen Sie es

Erzeugt bei jeder Iteration ein zusätzliches Leerzeichen vor dem zweiten Anführungszeichen.

Erläuterung

Verwendet das Programm "34s+cTZL "34s+cTZL, um zu erklären.

"34s+cTZL "34s+cTZL
"34s+cTZL "            String literal
           34s+        Prepend a double quote, Now the string is `"34s+cTZL `
               cT      Copy and trim trailing spaces
                 Z     Put a 0 under the top of stack
                       Stack now (from top to bottom): `["34s+cTZL,0,"34s+cTZL ]`
                  L    Collect all elements on stack, from bottom to top
                       Implicit output, 0 is converted to space.

JSTX , 4 Byte

£↕♣:

Probieren Sie es online!

Runenverzauberungen , 6 Bytes

"'<S@>

Probieren Sie es online!

Dieser war komisch. Alles, was ich tun musste, war ein von Jo King gefundenes~ Quine zu entfernen .

Jeder weitere Lauf hängt einen anderen <an das Ende an, zB:

"'<S@><<<<<<<<<

Alle machen nichts.

Direkte Kopie dieser Antwort auf eine verwandte Herausforderung. Es ist einfach so geschehen, dass es bei jeder Iteration um 1 Byte gewachsen ist (ein starkes Argument für diese Herausforderung ist ein Duplikat von diesem oder umgekehrt).

Jelly , 11 Bytes

“⁾;⁶;ØV” ṘV

Probieren Sie es online!

Wunder , 33 Bytes

f\ @(-> ol) ["f\ ";f;";f1";#0];f1

Eine interessante Variante des normalen Quines, bei der nach jeder Iteration eine 1 angehängt wird.

Progression:

f\ @(-> ol) ["f\ ";f;";f1";#0];f1
f\ @(-> ol) ["f\ ";f;";f1";#0];f11
f\ @(-> ol) ["f\ ";f;";f1";#0];f111
...

Erläuterung

f\ @                               #. Sets f to a function that does the following:
    (-> ol) [                      #.   Output each:
             "f\ ";                #.     String for declaration of f
                   f;              #.     Formatted representation of f's function
                     ";f1";        #.     String for call of f
                           #0      #.     Argument passed into f
                             ];f1  #. Call f with 1 as the argument

Einer der interessanten Teile dieses Quines ist, dass Wonder mit einer willkürlichen Genauigkeit arbeiten kann, so dass die Progression nach einer bestimmten Anzahl von Einsen nicht abbricht.

ColdFusion, 277 Byte

<cfset u=Chr(34)><cfset q="<cfset u=Chr(34)><cfset q=%s%s%s><cfoutput>%screateObject(%sjava%s,%sjava.lang.String%s).format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])%s</cfoutput>
"><cfoutput>#createObject("java","java.lang.String").format(q,[u,q,u,Chr(35),u,u,u,u,Chr(35)])#</cfoutput>

Dies ist eine triviale Modifikation meiner ColdFusion-Quine, die bei jedem weiteren Aufruf eine neue Zeile hinzufügt.

Lokal getestet auf lucee-express-5.2.6.60

Windows Batch, 38 36 Bytes

echo|set/p"=q">q&copy/b/y %0+q %0
::

Dieser Code erstellt eine Datei mit dem Namen "q", die den Buchstaben "q" enthält, und hängt sie dann an die Originaldatei an. Beachten Sie, dass "::" ein Alias ​​für "rem" ist, für das kein zusätzlicher Speicherplatz erforderlich ist.

2 Bytes dank user3493001 gespart.

Gol> <> , 7 Bytes

":r2ssH

Probieren Sie es online! Probieren Sie es online! Probieren Sie es online !!!

Dies ist eine einfache Variante des regulären Gol> <> Quine , fügt jedoch bei Hjeder Ausführung eine Kopie hinzu . Da der HBefehl das Programm anhält, Händert sich durch zusätzliches Beenden das Verhalten nicht.

T-SQL , 175 Byte

DECLARE @ VARCHAR(MAX)='DECLARE @ VARCHAR(MAX)=*SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @'SET @=TRIM(REPLACE(@,0x2a,CHAR(39)+@+CHAR(32)+CHAR(39)))PRINT @

Zuerst habe ich eine SQL-Quine geschrieben, dann habe ich sie modifiziert, um ein zusätzliches Leerzeichen hinzuzufügen (etwas inspiriert von dieser Antwort ).

Befunge-98 (PyFunge) , 22 bis 19 Bytes

r:#,_ #;'D2/'<,,@;"

Probieren Sie es online!

Fügt jede Generation ein <vor dem letzten "hinzu.

C # (Visual C # Interactive Compiler) , 89 Byte

var s="var s={0}{1}{0}+8;Write(s.Trim('8'),(char)34,s);"+8;Write(s.Trim('8'),(char)34,s);

Inspiriert von Kevin Cruijssens Antwort.

Probieren Sie es online!