Sie müssen ein Programm schreiben, das den Quellcode ausgibt

1. Größer als das ursprüngliche Programm (zeichenweise)
2. Gibt beim Ausführen ein anderes Programm aus, das größer ist als es selbst (dh das neue Programm ist auch eine gültige Antwort auf diese Herausforderung).

Das ist Code-Golf, also gewinnt die kürzeste Antwort.

GS2 (8636bd8e) , 0 Bytes

Dies druckt eine einzelne neue Zeile, die zwei neue Zeilen, die drei neue Zeilen usw. druckt.

Probieren Sie es online!

H9 + : 1 Zeichen

9

Stimmt. Ein Charakter. Gibt den Text auf 99 Flaschen Bier aus , was ein gültiges Programm ist. Alle fremden Daten zählen nicht, aber es gibt viele 9s darin.

Die Ausgabe des ausgegebenen Programms ist der Text zu 99 Flaschen Bier 59 Mal.

Diese Funktion gibt an, wie oft der Text ausgegeben wird, wenn Sie die Programmzeiten ausführen n(wenn meine Berechnung korrekt ist):

f(n) = 59n-1

GolfScript, 9 Zeichen

{.'.~'}.~

Dieser Code gibt Folgendes aus:

{.'.~'}{.'.~'}.~

welche Ausgänge:

{.'.~'}{.'.~'}{.'.~'}.~

welche Ausgänge:

{.'.~'}{.'.~'}{.'.~'}{.'.~'}.~

und so weiter.

Ich glaube, dies ist die kürzeste Antwort in einer "echten" Turing-vollständigen Programmiersprache.

Erläuterung:

Grundsätzlich ist der obige Originalcode eine "Quine-Ebene": Er gibt eine normale Quine aus, gefolgt von sich selbst.

In GolfScript ist jedes Codeblockliteral (z. B. {foo}), wenn es ungestört auf dem Stapel bleibt, ein Quine. Somit {.'.~'}gibt es sich selbst einfach aus, genau wie jeder andere Codeblock.

Der .~Code am Ende nimmt den letzten Codeblock auf dem Stapel, dupliziert ihn und führt die Kopie aus. Bei der Ausführung .'.~'dupliziert der Code innerhalb des Codeblocks das oberste Element auf dem Stapel (dh die Kopie von sich selbst) und hängt die Zeichenfolge an .~.

Am Ende des Programms setzt der GolfScript-Interpreter die Zeichenfolge und gibt alles auf dem Stapel aus, der in diesem Fall aus einem {.'.~'}Block mehr als der Eingabe plus der Zeichenfolge besteht .~.

Bonus:

Das Hinzufügen von a ]vor dem ersten .(um alle Codeblöcke auf dem Stapel in einem Array zu sammeln, bevor sie dupliziert werden) lässt es exponentiell wachsen:

{].'.~'}.~

Ausgänge:

{].'.~'}{].'.~'}.~

welche Ausgänge:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

welche Ausgänge:

{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}{].'.~'}.~

und so weiter.

Java 7: 0 Zeichen

Als Datei speichern Blank.java. Wenn Sie es als eine andere Datei speichern, ersetzen Sie eine Instanz von Blankdurch den entsprechenden Dateinamen.

Führen Sie dann in der Befehlszeile aus, indem Sie zuerst kompilieren und dann ausführen. Wenn das Kompilieren fehlschlägt, stoppen Sie.

Ich liste dies als Java 7 auf, da es für verschiedene Versionen von Java unterschiedlich ausgegeben werden kann.

Erste Ausgaben (nach stderr ausgegeben):

Error: Could not find or load main class Blank

Blank.java:1: error: class, interface, or enum expected
Error: Could not find or load main class Blank
^
Blank.java:1: error: reached end of file while parsing
Error: Could not find or load main class Blank
                                              ^
2 errors

Blank.java:1: error: class, interface, or enum expected
Blank.java:1: error: class, interface, or enum expected
^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                          ^
Blank.java:1: error:  expected
Blank.java:1: error: class, interface, or enum expected
                                     ^
Blank.java:1: error: as of release 5, 'enum' is a keyword, and may not be used as an identifier
Blank.java:1: error: class, interface, or enum expected
                                          ^
  (use -source 1.4 or lower to use 'enum' as an identifier)
Blank.java:1: error: = expected
Blank.java:1: error: class, interface, or enum expected
                                               ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:2: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:2: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:2: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:3: error: = expected
^
^
Blank.java:3: error: ';' expected
^
 ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
     ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
          ^
Blank.java:4: error: illegal start of type
Blank.java:1: error: reached end of file while parsing
           ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
            ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
              ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                   ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                 ^
Blank.java:4: error:  expected
Blank.java:1: error: reached end of file while parsing
                                        ^
Blank.java:4: error: = expected
Blank.java:1: error: reached end of file while parsing
                                         ^
Blank.java:4: error: ';' expected
Blank.java:1: error: reached end of file while parsing
                                              ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
     ^
Blank.java:5: error: ';' expected
Error: Could not find or load main class Blank
      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                      ^
Blank.java:5: error: = expected
Error: Could not find or load main class Blank
                                   ^
Blank.java:5: error:  expected
Error: Could not find or load main class Blank
                                              ^
Blank.java:6: error: = expected
                                              ^
                                              ^
Blank.java:6: error: ';' expected
                                              ^
                                               ^
Blank.java:7: error: reached end of file while parsing
2 errors
        ^
30 errors

HQ9 +, HQ9 ++ und ähnliche, 2 Zeichen

QQ

Dies ist die Ausgabe:

QQQQ

Rubin 27

Eine sehr leicht modifizierte Version davon ( via ):

puts <<3*3,3
puts <<3*3,3
3

Die Anzahl der putsAusdrucke dieser Zeile wächst exponentiell.

$ ruby quine.rb | ruby | ruby
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
puts <<3*3,3
3

$ ruby quine.rb | ruby | ruby | ruby | ruby | ruby | ruby | ruby | wc -l
    3283

Lambda-Kalkül - 29

Ein einfacher Lambda-Ausdruck

(λu.(u u)(u u))(λu.(u u)(u u))

Reduzierung dieser Laufzeit um eine Beta-Reduktionsrendite

((λu.(u u)(u u))(λu.(u u)(u u)))((λu.(u u)(u u))(λu.(u u)(u u)))

Und so weiter und so fort. Es ist eine einfache Variante des Klassikers, (λu.u u)(λu.u u)die in der Lambda-Rechnung eine Quine darstellt. Durch die doppelte Selbstanwendung erhalten wir die doppelte Leistung.

SH-Schrift, 9

cat $0 $0

Wächst exponentiell.

Entweder ausführen als sh whatever.shoder als ausführbar festlegen.

Windows-Version ist hier .

dc 11

Ziemlich einfach:

6579792
dfP

Die erste Zeile wird einmal pro Generation wiederholt:

$ dc growing_quine.dc
6579792
6579792
dfP

$ dc growing_quine.dc | dc | dc 
6579792
6579792
6579792
6579792
dfP

Die letzte Zeile enthält die folgenden Anweisungen: ddupliziert den letzten auf dem Stapel (6579792) abgelegten Wert (damit wir bei jeder Ausführung eine weitere Kopie erhalten), fdruckt den gesamten Stapel (der ein Bündel derselben Nummer ist) und Pdruckt die Nummer (6579792) als Byte-Stream aus, der als angezeigt wird dfP.

Redcode (rekursive Lösung)

Dies ist der Code des einfachsten Kriegers , der in Redcode geschrieben werden kann , des berühmten Wichtels :

MOV 0, 1

Bei der Ausführung schreibt der Code eine Kopie seines einzelnen Befehls an die nächste Adresse im Speicher. dann führt es aus, etc.

Python 3 - 55

print(open(__file__).read())
f=lambda:print('f()')
f()

Dies könnte verkürzt werden, indem __ file__ durch einen Dateinamen mit einem einzelnen Zeichen ersetzt und die Datei als solche gespeichert wird. Ich war jedoch der Meinung, dass diese Antwort eher dem Sinn der Frage entspricht. Nach einer Iteration gibt es aus:

print(open(__file__).read())
f=lambda:print('f()')
f()
f()

Smalltalk, 125 61 57

Die Golfversion sieht fast unleserlich aus, deshalb erkläre ich es zuerst (und verwende echte Bezeichner).

Dies ist eine Variante der selbstmodifizierenden Methode "Seltsamster Weg, um einen Stapelüberlauf zu erzeugen".

Die Methode druckt eine Hallo-Nachricht und ihre aktuelle Quelle aus (nur für die Demonstration). Anschließend wird der Code geändert, um eine längere Zeichenfolge auszugeben, und installiert. Schließlich wird der neue Code rekursiv aufgerufen.

Um mich vor einem sofortigen Durchgehen zu schützen, lässt es den Benutzer in jedem Zyklus bestätigen.

Kompiliere in Objekt:

eatMe_alice
   |msg mySource|

   mySource := thisContext method source.

   '**** Hello Alice' printCR.
   '  ---- my current code is:' printCR.
   mySource printCR.
   '  ---------------' printCR.

   (UserConfirmation confirm:'Again? ') ifTrue:[
       Object compile:
            (mySource
                copyReplaceString:'Hello ','Alice'
                withString:'Hello ','Alice !').
       self eatMe_alice
   ]

Starten Sie die Show, indem Sie "eatMe_alice" an ein beliebiges Objekt senden. nichts wird tun:

nil eatMe_alice

Eine gute Variante besteht darin, den neuen Code nicht rekursiv, sondern iterativ aufzurufen, indem Sie den Aufrufstapel aufheben und erneut in die neue Methode eingeben. Dies hat den Vorteil, dass es nicht zu einer Rekursionsausnahme kommt. Ersetzen Sie dazu den rekursiven Aufruf ("self eatMe_alice") durch:

thisContext resend

Golfen:

Offensichtlich wurde nicht nach Drucken und Selbstaufrufen gefragt, daher ist das kürzeste (für Golf), einfach einen Kommentar an meine eigene Quelle anzuhängen und ihn zurückzugeben. Als Nebeneffekt wird es auch für den nächsten Anruf installiert ...

x|s|Object compile:(s:=thisContext method source,'""').^s

SH-Skript, 12 8 7

Speichern Sie eine Datei mit

sed p *

in ein eigenes, leeres Verzeichnis und starte von diesem Verzeichnis aus mit sh [file]oder setze executable.

Alte Alternative mit 8 Zeichen , benötigt aber kein eigenes Verzeichnis. Speichern Sie eine Datei mit

sed p $0

und starte mit sh [file]oder setze executable.

Alte Alternative mit 12 Zeichen :

sed -i- p $0

Dies wird tatsächlich in die Programmdatei selbst ausgegeben, wobei jedoch nicht angegeben wurde, wo die Ausgabe erfolgen soll. Repliziert sich exponentiell.

JavaScript, 41 , 40 Zeichen

function f(){console.log(f+"f(f())")}f()

Wenn Sie es zum ersten Mal ausführen, gibt es sich ;f()am Ende selbst mit einem anderen aus . Nachfolgende Durchläufe der Ausgabe führen dazu, dass jede "Eingabe" -Quelle zweimal gedruckt wird.

alertwäre kürzer als, console.logaber ich halte mehrere Warndialogfelder nicht für "die" Ausgabe, während es vernünftig erscheint, mehrere Zeilen in der Konsole als Ausgabe aufzurufen.

J , 1 Byte

'

Probieren Sie es online!

Das offene Zitat gibt offensichtlich den offenen Zitatfehler an:

|open quote
|   '
|   ^
|[-1] /home/runner/.code.tio

Beachten Sie, dass die Fehler aufgrund der Art des J-Interpreters an STDOUT und nicht an STDERR ausgegeben werden.

Wenn das Obige als Code ausgeführt wird, wird Folgendes gedruckt:

|open quote
|   |   '
|       ^
|[-2] /home/runner/.code.tio

Dann

|open quote
|   |   |   '
|           ^
|[-2] /home/runner/.code.tio

und so weiter. Jedes Mal, wenn der Code ausgeführt wird, wird die zweite Zeile mit vier Bytes aufgefüllt |   , um die Anforderung dieser Herausforderung zu erfüllen.

J , richtige Quine-Variante, 25 Bytes

echo,~'echo,:~(,quote)'''

Probieren Sie es online!

Ausgänge

echo,:~(,quote)'echo,:~(,quote)'

Und dann gibt es sich zweimal in separaten Zeilen aus:

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

dann

echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'
echo,:~(,quote)'echo,:~(,quote)'

und so weiter.

Die erste Ausgabe ist eine einfache Variante von Standard-J-Quine . Die hinzugefügte ,:~Verkettung erfolgt vertikal, wobei das resultierende 2D-Array als zwei Zeilen derselben Zeichenfolge gedruckt wird.

Windows .BAT, 25

@COPY %~nx0+%~nx0 CON>NUL

Wächst exponentiell.

Entsprechende SH-Version hier .

Retikular, 11 Bytes, nicht konkurrierend

"'34'coo1o;

Dies ist das Standard-Quine-Framework, mit der Ausnahme, dass 1nach jeder Iteration ein zusätzliches gedruckt wird. Probieren Sie es online!

Erste Ausgaben:

"'34'coo1o;
"'34'coo1o;1
"'34'coo1o;11
"'34'coo1o;111

Mikroskript II, 6 Bytes

Nicht konkurrierende Sprache postdatiert die Herausforderung.

"qp"qp

Die erste Iteration fügt qpdem Ende ein Extra hinzu , und jede nachfolgende Iteration fügt dem Anfang eine zusätzliche Kopie dieses ursprünglichen Programms hinzu.

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.

EcmaScript 6 (51 Byte):

(_=x=>'(_='+_+Array(x++).join(','+_)+')('+x+')')(2)

Es produziert eine längere Version von sich selbst, die eine längere Version von sich selbst produzieren kann, die eine längere Version von sich selbst produzieren kann, usw. ...

PHP, 38

<?echo fgets(fopen(__FILE__,'r')).';';

Bei jedem Lauf wird ein Semikolon hinzugefügt.

ECMAScript 6 (38 Zeichen)

(f=_=>'(f='+f+')();(f='+f+')();')();

Welche Ausgänge:

(f=_=>'(f='+f+')();(f='+f+')();')();(f=_=>'(f='+f+')();(f='+f+')();')();

Bearbeiten

Sie könnten (28 Zeichen) tun:

(f=_=>'(f='+f+')();'+f())();

Es wird jedoch unendlich oft wiederkehren und niemals irgendetwas zurückgeben ... aber dies kann gelöst werden, indem man so etwas macht (42 Zeichen):

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);

Welches wird ausgegeben:

(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(3);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(2);(f=_=>_?'(f='+f+')('+_+');'+f(_-1):'')(1);

Common Lisp, 16 Zeichen

(print `(or ,-))

Zugegeben, es ist nur interaktiv, aber in der Lage zu sein, auf das aktuelle Formular der obersten Ebene zu verweisen, ist wahrscheinlich die beste Möglichkeit, ein nicht triviales Programm zu minimieren, das der Spezifikation entspricht.

Was wirklich interessant wäre, ist das, was am schnellsten explodiert. Vielleicht sowas

(print `(progn ,@(loop repeat (length -) collect -)))

Julia, 66 Zeichen

x="print(\"x=\$(repr(x))\\n\$x;\"^2)";print("x=$(repr(x))\n$x;"^2)

Ausgabe (134 Zeichen):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Ergebnis der Ausführung des Ergebnisses (268 Zeichen):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

nächstes Ergebnis (536 Zeichen):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Nächstes Ergebnis (1072 Zeichen):

x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);x="print(\"x=\$(repr(x))\\n\$x;\"^2)"
print("x=$(repr(x))\n$x;"^2);

Ich hoffe das entspricht den Regeln.

Es erzeugt eine größere Ausgabe und die Ausgabe selbst ist ein gültiger Quellcode, der wieder eine größere Ausgabe erzeugt.

05AB1E, 15 Byte, nicht konkurrierend

0"DÐ34çý"DÐ34çý

Probieren Sie es online!

Drucke 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
die druckt 0"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý"DÐ34çý,
etc.

Evoloop, 9 × 9 Rechteck (81 Zellen)

Der in Golly enthaltene Evoloop-Zellularautomat unterstützt Muster, die sich "quineartig" nachbilden. Insbesondere enthalten diese Muster jeweils ein "Programm"; Ein Muster reproduziert sich, indem es zuerst das Programm ausführt (das den "Körper" der Tochter erzeugt) und dann das Programm in die Tochter kopiert.

Das Obige gilt sowohl für den bekannteren Zellularautomaten "Langton's Loops" als auch für Evoloop. Evoloop weist jedoch einen interessanten Unterschied auf: Es ist einfach, ein Muster zu erstellen, das in jeder nachfolgenden Generation wächst.

(Viel mehr interessant, meiner Meinung nach , ist die Tatsache , dass Evoloop ist ein einfacher zellulären Automaten , die Muster enthält , die sich selbst reproduzieren und in eine sehr getreuen Weise entwickeln! Ich denke , die einzigen bekannten zelluläre Automaten , die dies tun , sind Evoloop und seine Nachkommen Ein Nachteil von Evoloop besteht jedoch darin, dass es ein bestimmtes "bestes" Genom gibt, wobei die Evolution letztendlich immer zu diesem einen Genom konvergiert.

Diese Vorlage weist zwei Mängel auf. Eines ist, dass es nicht klar ist, was die "Ausgabe" eines zellularen Automaten ist. Aber ich denke, dass ein sich selbst reproduzierender Automat "nah genug" ist, um ein Quine zu sein; es ist sicherlich nicht weniger interessant! Das andere Manko ist, dass diese Muster nicht nur eine einzige Kopie von sich selbst erzeugen. Jede Kopie des ursprünglichen Musters versucht, unendlich viele Kopien von sich selbst zu erstellen, und diese Kopien interagieren letztendlich auf destruktive Weise miteinander. Ich glaube, ich habe die Anforderungen dieser Herausforderung im Geiste erfüllt, aber nicht im Buchstaben.

Ohne weiteres lautet das Muster:

022222220
270170172
212222202
202000212
272000272
212000202
202222212
271041032
022222250

Hier ist noch einmal das Muster in einem Format, das kopiert und in Golly eingefügt werden kann:

x = 9, y = 9, rule = Evoloop
.7B$BG.AG.AGB$BA5B.B$B.B3.BAB$BGB3.BGB$BAB3.B.B$B.5BAB$BGA.DA.CB$.6BE
!

Okay, aber wie sieht es aus? Es sieht aus wie das:

In der obigen Animation können Sie sehen, wie das ursprüngliche Muster eine größere Tochter erzeugt, die eine größere Enkelin erzeugt, dann eine größere Urenkelin und schließlich eine noch größere Ur-Ur-Enkelin, die beginnt, eine noch größere dritte Ur-Ur-Tochter zu konstruieren. Enkelin. Wenn Sie dieses Muster für eine lange Zeit durchlaufen würden, würde es für immer so weitergehen (oder vielleicht würden sie irgendwann von den weiterentwickelten Organismen überholt werden, die sich viel schneller reproduzieren können; ich bin mir nicht sicher).

BATCH, 26

Fügen Sie diesen Code in eine beliebige .bat-Datei ein, und die Ausführung wird fortgesetzt (in einer Endlosschleife), und die Datei wächst ebenfalls.

echo echo %0 ^>^> %0 >> %0

PYG (6)

P(Q,Q)

Gibt den eigenen Quellcode aus, getrennt durch Zeilenumbrüche. Die zweite Generation wäre

P(Q,Q)
P(Q,Q)

und so weiter.

OIL , 83 Bytes

0
0
1
1
1
4
1
11
4
1
11
1
2
2
1
12
18
10
18
1
32
22
1
18
26
4
26
8
18
11
6
17
4
26

Es werden zuerst zwei Zeilen mit einer Null gedruckt und dann jede Zeile mit Zeile 1 verglichen. Wenn sie gleich sind (was der Fall ist, wenn die Datei erschöpft ist), wird gedruckt, was sich in Zelle 26 befindet. Die resultierende Ausgabe sieht wie folgt aus: das gleiche, außer mit einem hinzugefügten 33, der nichts tut. Nächstes Mal wird eine weitere Zeile hinzugefügt und so weiter.

Hilfe, WarDoq! 1 Byte.

H

Druckt Hello, World!.

Andere Zeichen als H sind gültiger (und sicherer) Quellcode (der andere Varianten von Hello World druckt).