Bilden Sie ein Quine.

Scheint einfach, oder? Nun, dieses Quine muss sich selbst plus sein erstes Zeichen ausgeben, das sich dann plus sein zweites Zeichen ausgibt, und so weiter.

Auf diese Weise sollte das Quine in mehreren Generationen zwei Kopien ausgeben.

Beispiel: Lässt Ihren Code sein x. Laufen sollte es ausgeben x + x[:1]. Ausführen des resultierenden Programms sollte ausgeben x + x[:2]und so weiter ...

Wenn Ihr Code ausgeführt wurde foobar, sollte dies ausgegeben werden foobarf. Laufen sollte dies ausgeben foobarfo. Und so weiter und so fort nach diesem Muster:

foobar
foobarf
foobarfo
foobarfoo
foobarfoob
foobarfooba
foobarfoobar
foobarfoobarf

Ihr Programm muss länger als 2 Bytes sein und darf bei jeder Iteration nur EIN zusätzliches Zeichen seines eigenen Codes ausgeben.

Zsh ,110 108 100 Bytes

a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}
a=`<&0`<<''<<<t;b=${a:0:50};printf $b$b${a:0:-50}

Probieren Sie es online!

So ist es möglich.

Erläuterung

a=`<&0`<<''<<<t;       # Set A to everything following this line, until eof or
                       #   an empty line (which never happens before eof) encountered.
                       # A "t" is appended to prevent automatic trimming of newlines.
b=${a:0:50};           # Set B to the first line.
printf $b$b${a:0:-50}  # Print two copies of B and
                       #   A with 50 trailing characters removed.

R, 289 Bytes

s<-c("s<-", "i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#")
i=get0('i',ifnotfound=0)+1;p=paste0(s,substr(get0('p',ifnotfound=s),1,i),collapse='');cat(s[1]);dput(s);cat(paste0(s[2],substr(p,1,i)))#

Verdienst dieser Inspirationsquelle. Funktioniert nur, wenn es in derselben R-Umgebung ausgeführt wird wie das vorherige Quine.

Alice , 29 Bytes

4P.a+80pa2*&wdt,kd&w74*,.ok@

Probieren Sie es online!

Das nicht druckbare Zeichen ist 0x18.

Erläuterung

Das "Problem mit den üblichen Fungeoid-Quines ist, dass wenn wir den gesamten Quellcode wiederholen, wir auch zusätzliche bekommen "und die Zeichenfolge nicht mehr den gesamten Quellcode abdeckt. Ich nehme an, deshalb wird in der vorhandenen Antwort gstattdessen der Cheat-Y- Ansatz verwendet.

Diese Antwort verwendet den "-basierten Ansatz, aber anstatt ein "in die Quelle aufzunehmen, schreiben wir es zur Laufzeit in das Programm. Auf diese Weise wird es immer nur eine geben, "unabhängig davon, wie oft das Programm wiederholt wird (da wir es unabhängig von der Programmgröße nur auf eine bestimmte Koordinate schreiben).

Die allgemeine Idee ist dann, dass wir eine Darstellung des gesamten Quellcodes auf dem Stapel erstellen, aber nur die ersten 29 der Zeichen (dh die Programmlänge) durchlaufen, wobei die Länge der Schleife durch die Größe des Codes bestimmt wird. Daher können wir tatsächlich beliebige Zeichen (außer Zeilenvorschübe) anhängen, @und das Ergebnis ist immer eine zyklische Wiederholung des Kernprogramms, ein Zeichen länger als die Quelle.

4P   Push 4! = 24. This is the code point of the unprintable, which we're 
     using as a placeholder for the quote.
.a+  Duplicate it and add 10, to get 34 = '"'.
80p  Write '"' to cell (8,0), i.e. where the first unprintable is.
    Placeholder, becomes " by the time we get here, and pushes the code
     points of the entire program to the stack. However, since we're already
     a good bit into the program, the order will be messed up: the bottom
     of the stack starts at the 24 (the unprintable) followed by all 
     characters after it (including those from extraneous repetitions). Then 
     on top we have the characters that come in front of the `"`. 
     So if the initial program has structure AB, then any valid program has
     the form ABC (where C is a cyclic repetition of the initial program),
     and the stack ends up holding BCA. We don't care about C, except to
     determine how big the program is. So the first thing we need to do is
     bring B to the top, so that we've got the initial program on top of
     the stack:
a2*  Push 10*2 = 20.
&w   Run the following section 21 times, which is the length of B.

  dt,  Pull up the value at the bottom of the stack.

k    End of loop.
d&w  Run the following section D+1 times, where D is the length of ABC.

  74*  Push 28, one less than the number of characters in AB.
  ,    Pull up the 29th stack element, which is the next character to print.
  .o   Print a copy of that character.

k    End of loop.
@    Terminate the program.

Perl 5 , 83 Bytes (einschließlich der letzten Newline)

$_=q($/=$;;$_="\$_=q($_);eval
__END__
".<DATA>;print$_,/(.).{82}\z/s);eval
__END__

Probieren Sie es online!

Das gute alte __DATA__Token macht es einfach, einen beliebigen String an ein beliebiges Perl-Programm anzuhängen, auf das das Hauptprogramm dann über das <DATA>Datei-Handle zugreifen kann (und tatsächlich verwendet __END__, was aus Gründen der Abwärtskompatibilität dasselbe tut, anstatt __DATA__zwei zusätzliche Bytes zu sparen). .

Beachten Sie, dass dieses Programm nicht nicht seinen eigenen Quellcode lesen, aber nur die zusätzlichen Eingabedaten an die Quelle nach dem beigefügten __END__Token. __END__Tatsächlich funktioniert das Token und alles, was dahinter steht, wie ein String-Literal, das am Ende der Eingabe endet.

Beachten Sie auch, dass dieses Programm in einer neuen Zeile enden muss, um die Spezifikation genau zu erfüllen. Wenn dies nicht der Fall ist, wird die neue Zeile __END__ohnehin automatisch nach der zweiten angefügt , aber dann entspricht die Ausgabe der ersten Iteration nicht mehr genau dem Code plus dem ersten Byte.

Befunge-98 , 30 Bytes

0>:#;0g:840#;+*#1-#,_$a3*%0g,@

Probieren Sie es online!

Mein Versuch, Befunge-98 zu verwenden, das ein mit Leerzeichen abgeschlossenes Quine verwendet, das auch zählt, wie viele Zeichen ausgegeben wurden. Verwendet jedoch den gBefehl.

PHP, 146 Bytes

ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>ob_start(function($s){return($u=substr($s,0,73)).$u.substr($s,0,-72);})?>

Es sollte über die -rBefehlszeile ausgeführt werden.

Runenverzauberungen , 61 Bytes

803X4+kw.'.q}͍}͍}͍}͍}͍}͍}͍}͍}͍::l͍5X-:}-$:l͍{-1--@

Probieren Sie es online!

Verwendet einen ähnlichen Ansatz wie die Alice-Antwort: Schreibt den Zeichenfolgenbefehl reflektierend "in den Code, sodass es nur eine gibt. Es bleibt noch viel Zeit, Zeichenfolgen und Stapel zu manipulieren, um das ursprüngliche Programm wiederherzustellen, wie viele zusätzliche Bytes benötigt werden, und die erforderlichen Hunks zu drucken.

Die }͍Sequenz dreht die speicherinterne Zeichenfolgendarstellung so, dass sie 803X4+kwaufgrund der Position von am Anfang und nicht am Ende angezeigt wird, "und es gibt keine einfachere Möglichkeit, diese Operation durchzuführen, ohne viele unangenehme Zahlen berechnen zu müssen .

Während das ursprüngliche Programm 61 Bytes lang ist, ist seine String-Länge nur 50, was einfach zu konstruieren ist, 5Xund es war nur ein Zufall, dass dies nicht ausgefüllt werden musste, nachdem alle notwendigen Funktionen enthalten waren (z. B. wäre ein Programm der Länge 49 einfacher gewesen) codieren wie 50mit einem Füllbyte, als ein Literal zu codieren 49, während 51es als 5X3+oder 53 codiert würde , wobei es seine eigenen zusätzlichen Bytes berücksichtigen müsste ).