Jak wiemy, quine to program, który wyświetla swój własny kod źródłowy. Można również napisać program, który wypisuje inny, inny program, który wypisuje ponownie pierwszy program. Na przykład program Python 2

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

po uruchomieniu wyświetli następujący tekst:

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

Po uruchomieniu jako program w języku Python, ponownie wyświetli oryginalny kod. Nazywa się to iterem iteracyjnym . Ponieważ musisz go uruchomić dwa razy, aby odzyskać oryginalny kod, mówimy, że ma on okres 2 . Ale oczywiście możliwe są znacznie wyższe okresy.

Twoim wyzwaniem jest napisanie iteracyjnej quine z tak długim okresem, jak to możliwe, w 100 bajtach lub mniej , w wybranym języku. (Zauważ, że mój powyższy przykład nie pasuje do tej specyfikacji, ponieważ ma 119 bajtów, w tym końcowy znak nowej linii).

Proszę zwrócić uwagę na następujące zasady i wyjaśnienia:

• Obowiązują zwykłe reguły quine, tzn. Twój program nie może korzystać z funkcji językowych, które umożliwiłyby mu bezpośredni dostęp do własnego kodu źródłowego.
• Powtarzane wyjścia muszą ostatecznie powrócić do dokładnie twojego oryginalnego kodu, i musisz dołączyć demonstrację lub dowód, że tak będzie.
• Musisz także wyjaśnić, dlaczego cykl trwa tak długo, jak to mówisz. Nie musi to być na poziomie matematycznego dowodu, ale powinno być przekonujące dla kogoś, kto zna twój język. (Ta reguła jest tutaj, ponieważ spodziewam się, że niektóre odpowiedzi będą dotyczyły bardzo, bardzo dużych liczb).
• Można powiedzieć coś w stylu „co najmniej 1 000 000 iteracji” zamiast podawać dokładną liczbę, o ile można udowodnić, że jest ona co najmniej tak długa. W takim przypadku wynik wyniósłby 1 000 000. W przeciwnym razie twój wynik jest okresem twojego quine.
• Limit 100 bajtów dotyczy tylko twojego programu początkowego - programy, które wysyła, mogą być dłuższe, ale oczywiście będą musiały wrócić do 100 bajtów, aby wyprowadzić oryginalny kod.
• Możesz założyć, że twoja maszyna ma nieskończoną pamięć RAM i nieskończony czas działania, ale nie możesz zakładać nieograniczonej precyzji typów danych (takich jak liczby całkowite), jeśli twój język ich nie ma. Państwo może założyć, nie ma ograniczeń co do długości wkładu Twój parser może obsługiwać.
• Najwyższy wynik wygrywa.

Uwaga: istnieje istniejące wyzwanie o nazwie Quit Whining; Rozpocznij quinowanie, które obejmuje również iterowanie quinów. Jednak oprócz tego, że opierają się na tej samej koncepcji, są to zupełnie inne rodzaje wyzwań. Drugi to prosty golf, podczas gdy ten (celowo!) Jest naprawdę zajętym problemem bobra w przebraniu. Techniki potrzebne do uzyskania dobrej odpowiedzi na to pytanie prawdopodobnie będą bardzo różnić się od potrzebnych do udzielenia odpowiedzi na inne pytanie, a to w dużej mierze z założenia.

PHP, okres 2 100 000 000

Kto by pomyślał, że jest to możliwe w PHP ?! :-)

To właściwie mój pierwszy w historii quine i ma 99 bajtów długości:

<?$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);

Chociaż PHP obsługuje większe wartości niż w przypadku 2 * 10^8, przez przełączenie integersię double, przyrostu nie działa (prowadzi do nieskończonej pętli) i nie znaleziono jeszcze rozwiązania, które pasuje do 100 bajtów. Jeszcze.

Dowód jest dość prosty, ponieważ liczy się tylko z każdą iteracją, aż osiągnie punkt zerowy 2,1 miliarda.

Podziękowania dla Dave'a , który zamieścił podejście w pseudo-kodzie w komentarzach oraz dla Boba Twellsa , od którego skopiowałem kod dla minimalnej ilości PHP.

Program testowy (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;
    }
}

Cóż, przynajmniej jestem pierwszym, który odpowiedział.

Mathematica, okres 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!]]

Zauważ, że wyniki są opisane w notacji Hyper-E . Iteracje zamieniają finał Nest[#!,9,9^9^99!]na dziesiętne rozszerzenia Nest[#!,9,9^9^99!]- 1, Nest[#!,9,9^9^99!]- 2, Nest[#!,9,9^9^99!]- 3, ..., 3, 2, 1 i powrót do Nest[#!,9,9^9^99!].

R, losowy okres z oczekiwaniem 2 ^ 19936-0,5

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

Domyślny generator liczb losowych R ma okres 2 ^ 19937-1 i równomierny rozkład w 623 kolejnych wymiarach. Tak więc gdzieś (ale tylko raz) w tym okresie będzie wektor o długości 623 zer. Kiedy się tam dostaniemy (i zrównamy z początkiem sekwencji), suma kolejnych 623 losowych liczb U [0,1] wyniesie zero i wrócimy do naszego oryginalnego programu.

Zauważ, że program z dużym prawdopodobieństwem przejdzie kilka razy przez ten sam niezerowy stan, zanim powróci do zera. Na przykład, suma 311.5 jest najbardziej prawdopodobna i istnieje wiele sposobów, które mogą się wydarzyć, ale RNG pozwala, aby okres 0 był dłuższy niż okres dla 311,5.

JavaScript, okres 9 007 199 254 700 000

Nie zamierzam wygrywać, ale fajnie było pracować z JavaScript w tym wyzwaniu:

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

Wykonuje następujący cykl:

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

Uwaga: Możesz zmniejszyć go o 18 bajtów, usuwając tylko ~ 0,08% wyniku, tak jak poniżej:

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

C, okres 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);}

Na podstawie odpowiedzi PHP (oczywiście). Zaktualizuję z wyjaśnieniem, kiedy będę miał czas.

C (gcc) , 66 bajtów, okres 2 ^ 64

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

Wypróbuj online!

2 ^ 64 liczb jest dostępnych w unsigned longliczbie całkowitej. Dlatego okres 2 ^ 64.

Python 2

Kropka: $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$

Dzięki @Bubbler za zwiększenie okresu od $9\uparrow9\uparrow(99\uparrow\uparrow12)+1$ do teraz

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

Wypróbuj online!

W kodzie b=0zmiany do b=1tego czasu b=2i tak dalej, aż do osiągnięcia, b=decimal expansion of the periodresetują się z powrotem dob=0

Gol> <> , 70 bajtów, okres 325883196621297064957600206175719056476804879488288708188003274919860959534770101079512433396348062803055739640225395758790852315876868469390603793729639715908136196505908165227136154287969475839017544811926036808089596209081885772040898530121921794489026069641113281250

Inne mądre znane jako naprawdę duże (3.25E270)

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

Jest to w rzeczywistości zmieniona wersja odpowiedzi, którą umieściłem w iteratorze o długości 500 bajtów

":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

Mam nadzieję, że udało mi się uzyskać prawidłowy wynik i nie ma błędów. Nie ma prawdziwego sposób właściwie obliczyć tę wartość, to jest teoretyczna. Ale stary, to ogromna liczba !!!

Wypróbuj online!