Wie wir wissen, ist ein Quine ein Programm, das seinen eigenen Quellcode ausgibt. Es ist jedoch auch möglich, ein Programm zu schreiben, das ein anderes, anderes Programm ausgibt, das das erste Programm erneut ausgibt. Zum Beispiel das Python 2-Programm

x = '''x = {}
print 'print '+'"'*3+x.format("'"*3+x+"'"*3)+'"'*3'''
print 'print '+'"'*3+x.format("'"*3+x+"'"*3)+'"'*3

gibt beim Ausführen den folgenden Text aus:

print """x = '''x = {}
print 'print '+'"'*3+x.format("'"*3+x+"'"*3)+'"'*3'''
print 'print '+'"'*3+x.format("'"*3+x+"'"*3)+'"'*3"""

Wenn es als Python-Programm ausgeführt wird, wird der ursprüngliche Code erneut ausgegeben. Dies wird als iterierende Quine bezeichnet . Da Sie es zweimal ausführen müssen, um den ursprünglichen Code zurückzugewinnen, haben wir die Periode 2 . Aber natürlich sind viel höhere Perioden möglich.

Ihre Herausforderung besteht darin, eine iterierende Quine mit einem möglichst langen Zeitraum in maximal 100 Byte in der Sprache Ihrer Wahl zu schreiben . (Beachten Sie, dass mein Beispiel oben nicht zu dieser Spezifikation passt, da es 119 Byte enthält, einschließlich der nachfolgenden Zeilenumbruch.)

Bitte beachten Sie die folgenden Regeln und Erläuterungen:

• Es gelten die üblichen Quine-Regeln, dh Ihr Programm kann keine Sprachfunktionen verwenden, mit denen es direkt auf seinen eigenen Quellcode zugreifen kann.
• Die iterierten Ausgaben müssen schließlich zu genau Ihrem ursprünglichen Code zurückkehren, und Sie müssen eine Demonstration oder einen Beweis dafür beifügen.
• Sie müssen auch eine Erklärung hinzufügen, warum der Zyklus so lang ist, wie Sie es sagen. Dies muss nicht unbedingt ein mathematischer Beweis sein, sondern sollte jemanden überzeugen, der mit Ihrer Sprache vertraut ist. (Diese Regel ist hier, weil ich erwarte, dass einige der Antworten sehr, sehr große Zahlen enthalten.)
• Es ist in Ordnung, etwas wie "mindestens 1.000.000 Iterationen" zu sagen, anstatt die genaue Anzahl anzugeben, solange Sie nachweisen können, dass es mindestens so lang ist. In diesem Fall wäre Ihre Punktzahl 1.000.000. Andernfalls ist Ihre Punktzahl die Periode Ihrer Quine.
• Das 100-Byte-Limit gilt nur für Ihr ursprüngliches Programm - die von ihm ausgegebenen Programme können länger sein, obwohl sie natürlich irgendwann wieder auf 100 Byte reduziert werden müssen, um Ihren ursprünglichen Code auszugeben.
• Sie können davon ausgehen, dass Ihr Computer über unendlich viel RAM und unendlich viel Laufzeit verfügt. Sie können jedoch keine Datentypen mit unbegrenzter Genauigkeit (z. B. Ganzzahlen) annehmen, wenn Ihre Sprache diese nicht hat. Sie können davon ausgehen, dass die Länge der Eingabe, die Ihr Parser verarbeiten kann, unbegrenzt ist.
• Die höchste Punktzahl gewinnt.

Bitte beachten Sie: Es gibt eine Herausforderung namens Quit Whining. Starten Sie Quining , bei dem auch Quines iteriert werden. Abgesehen davon, dass sie auf demselben Konzept basieren, handelt es sich jedoch um völlig unterschiedliche Arten von Herausforderungen. Der andere ist Straight-Up-Code-Golf, während dieser (absichtlich!) Wirklich ein geschäftiges Biberproblem in der Verkleidung ist. Die Techniken, die erforderlich sind, um eine gute Antwort auf diese Frage zu erhalten, unterscheiden sich wahrscheinlich stark von denen, die zur Beantwortung der anderen Frage erforderlich sind, und dies ist sehr beabsichtigt.

PHP, Zeitraum 2.100.000.000

Wer hätte gedacht, dass dies in PHP möglich ist?! :-)

Dies ist tatsächlich meine erste Quine und sie ist 99 Bytes lang:

<?$i=1;$i*=21e8>$i;printf($a='<?$i=%d;$i*=21e8>$i;printf($a=%c%s%c,++$i,39,$a,39);',++$i,39,$a,39);

Obwohl PHP größere Zahlen unterstützt als 2 * 10^8durch Umschalten von integerauf double, funktioniert das Inkrement nicht mehr (führt zu einer Endlosschleife) und ich habe keine andere Lösung gefunden, die in die 100 Bytes passt. Noch.

Der Beweis ist ziemlich einfach, da er nur bei jeder Iteration hochzählt, bis der Rücksetzpunkt bei 2,1 Milliarden erreicht ist.

Dank an Dave , der den Ansatz in Pseudo-Code in den Kommentaren gepostet hat , und an Bob Twells , von dem ich den Code für ein minimales PHP-Quine kopiert habe.

Testprogramm (sloooooow):

<?php
$o = file_get_contents('quine.php');
for ($i = 0; $i < 22e8; $i++) {
    if ($i%2==0) exec('php q > p'); else exec('php p > q');
    $a = file_get_contents(($i%2==0) ? 'p' : 'q');
    echo "\r" . str_pad($i,6,' ') . ":\t$a";
    if ($a == $o) {
        die;
    }
}

Zumindest bin ich der erste, der antwortet.

Mathematica, Zeitraum E8.5678 # 3 E2.1923 # 4 ~ E6.2695 # 3 # 2

Print[ToString[#0, InputForm], "[", #1 - 1 /. 0 -> "Nest[#!,9,9^9^99!]", "]"] & [Nest[#!,9,9^9^99!]]

Beachten Sie, dass die Ergebnisse in Hyper-E-Notation beschrieben sind . Die Iterationen ersetzen das Finale Nest[#!,9,9^9^99!]durch die Dezimalerweiterungen von Nest[#!,9,9^9^99!]- 1, Nest[#!,9,9^9^99!]- 2, Nest[#!,9,9^9^99!]- 3, ..., 3, 2, 1 und zurück zu Nest[#!,9,9^9^99!].

R, zufällige Periode mit Erwartung 2 ^ 19936-0.5

f=function(){
    options(scipen=50)
    body(f)[[4]]<<-sum(runif(623))
    0
    cat("f=")
    print(f)
}

Der Standard-Zufallszahlengenerator von R hat eine Periode von 2 ^ 19937-1 und eine Gleichverteilung in 623 aufeinanderfolgenden Dimensionen. Somit wird irgendwo (aber nur einmal) in seiner Periode ein 623 langer Vektor von Nullen sein. Wenn wir dort ankommen (und mit dem Beginn der Sequenz ausgerichtet sind), ist die Summe der nächsten 623 zufälligen U [0,1] -Zahlen Null und wir kehren zu unserem ursprünglichen Programm zurück.

Beachten Sie, dass das Programm mit sehr hoher Wahrscheinlichkeit mehrmals denselben Zustand ungleich Null durchläuft, bevor es auf Null zurückkehrt. Zum Beispiel ist die Summe 311,5 am wahrscheinlichsten, und es gibt sehr viele Möglichkeiten, die passieren können, aber das RNG erlaubt, dass die Periode für 0 länger ist als die Periode für 311,5.

JavaScript, Zeitraum 9.007.199.254.700.000

Ich werde nicht gewinnen, aber es hat Spaß gemacht, mit JavaScript an dieser Herausforderung zu arbeiten:

a="a=%s;console.log(a,uneval(a),%.0f-1||90071992547e5)";console.log(a,uneval(a),1-1||90071992547e5)

Folgt dem folgenden Zyklus:

a="a=%s;console.log(a,uneval(a),%.0f-1||90071992547e5)";console.log(a,uneval(a),1-1||90071992547e5)
a="a=%s;console.log(a,uneval(a),%.0f-1||90071992547e5)";console.log(a,uneval(a),9007199254700000-1||90071992547e5)
a="a=%s;console.log(a,uneval(a),%.0f-1||90071992547e5)";console.log(a,uneval(a),9007199254699999-1||90071992547e5)
a="a=%s;console.log(a,uneval(a),%.0f-1||90071992547e5)";console.log(a,uneval(a),9007199254699998-1||90071992547e5)
// etc...
a="a=%s;console.log(a,uneval(a),%.0f-1||90071992547e5)";console.log(a,uneval(a),3-1||90071992547e5)
a="a=%s;console.log(a,uneval(a),%.0f-1||90071992547e5)";console.log(a,uneval(a),2-1||90071992547e5)
a="a=%s;console.log(a,uneval(a),%.0f-1||90071992547e5)";console.log(a,uneval(a),1-1||90071992547e5)
a="a=%s;console.log(a,uneval(a),%.0f-1||90071992547e5)";console.log(a,uneval(a),9007199254700000-1||90071992547e5)
// and so on

Hinweis: Sie können es um 18 Byte verkürzen, während Sie nur ~ 0,08% der Punktzahl entfernen, wie folgt:

a="a=%s;console.log(a,uneval(a),%.0f-1||9e15)";console.log(a,uneval(a),1-1||9e15)

C, Zeitraum 2.100.000.000

unsigned long long i;main(a){i=1;i*=21e8>i;printf(a="ungisned long long i;main(a){i=%d;i*=21e8>i;printf(a=%c%s%2$c,++i,34,a);}",++i,34,a);}

Basierend auf der PHP-Antwort (offensichtlich). Wird mit Erklärung aktualisiert, wenn ich Zeit habe.

C (gcc) , 66 Bytes, Periode 2 ^ 64

f(s){printf(s="f(s){printf(s=%c%s%1$c,34,s,%lu+1L);}",34,s,0+1L);}

Probieren Sie es online aus!

2 ^ 64 Zahlen sind in einer unsigned longganzen Zahl verfügbar . Daher ein Zeitraum von 2 ^ 64.

Python 2

$9\uparrow((99\uparrow\uparrow(9\uparrow((99\uparrow\uparrow(9\uparrow((99\uparrow\uparrow(9\uparrow\uparrow5-1))\uparrow9)-1))\uparrow9)-1))\uparrow9)+1$

$9\uparrow9\uparrow(99\uparrow\uparrow12)+1$

b=0;s="print'b=%d;s=%r;exec s'%(-~b%eval('9**9'*eval('9**9'*eval('9**9'*9**9**9**9**9))),s)";exec s

Probieren Sie es online aus!

Im Code b=0ändert sich das zu b=1dann b=2und so weiter, bis es erreicht und b=decimal expansion of the perioddann wieder zurückgesetzt wirdb=0

Gol> <> , 70 Bytes, Zeit 325883196621297064957600206175719056476804879488288708188003274919860959534770101079512433396348062803055739640225395758790852315876868469390603793729639715908136196505908165227136154287969475839017544811926036808089596209081885772040898530121921794489026069641113281250

Andere weise als wirklich groß bekannt (3.25E270)

":1=l8:*6+=S&Q~:'~'=Q~~'H#'||lPffXfX=?1:1=Q$~$~|:1)lPffXfX(Q?:|r2ssH##

Dies ist eigentlich eine geänderte Version der Antwort, die ich auf den 500-Byte-Iterator gegeben habe

":1=l8:*6+=S&Q~:'~'=Q~~'H#'||//if last is equal to 1 and length is 71, delete the delete char, if the last char is '~', delete and push 'H#', which will later return to 'H##', completing the cycle!
lPffXfX=?1:1=Q$~$~|          //if length is equal to 15^15^15, then start delete process(append ascii one)
:1)lPffXfX(Q?:|              //if the last character is not 1 (the delete checker), and length is less than 15^15^15, duplicate the last value and append
r2ssH##                      //push the " to the front and output the whole thing

Hoffentlich habe ich die Punktzahl richtig verstanden und es gibt keine Fehler. Es gibt keine wirkliche Möglichkeit, diesen Wert tatsächlich zu berechnen, es ist theoretisch. Aber Mann, das ist eine riesige Zahl !!!

Probieren Sie es online aus!