Twoim celem jest napisanie programu, który wypisze liczbę. Im większa liczba, tym więcej punktów otrzymasz. Ale bądź ostrożny! Długość kodu jest zarówno ograniczona, jak i ważona w funkcji oceniania. Twój wydrukowany numer zostanie podzielony przez sześcian liczby bajtów użytych do rozwiązania .

Powiedzmy, że wydrukowałeś, 10000000a twój kod ma 100długość bajtów. Twój końcowy wynik to 10000000 / 100^3 = 10.

Aby uczynić to wyzwanie nieco trudniejszym, należy przestrzegać innych zasad.

• Nie możesz używać cyfr w swoim kodzie (0123456789);
• Państwo może używać matematyczne / fizyczne / etc. stałe, ale tylko jeśli są mniejsze niż 10. (np. Możesz użyć Pi ~ = 3,14, ale nie możesz użyć stałej Avogadro = 6e23)
• Rekurencja jest dozwolona, ale wygenerowana liczba musi być skończona (więc nieskończoność nie jest akceptowana jako rozwiązanie. Twój program musi zakończyć się poprawnie, przy założeniu nieograniczonego czasu i pamięci oraz wygenerować żądany wynik);
• Nie można używać operacji *(mnożenie), /(dzielenie), ^(moc) ani w żaden inny sposób do ich wskazania (np. 2 div 2Nie jest dozwolone);
• Twój program może wypisać więcej niż jedną liczbę, jeśli jest to potrzebne . Tylko najwyższy będzie liczył się do punktacji;
• Można jednak łączyć łańcuchy: oznacza to, że każda sekwencja sąsiadujących cyfr będzie traktowana jako pojedyncza liczba;
• Twój kod będzie działał bez zmian. Oznacza to, że użytkownik końcowy nie może edytować żadnego wiersza kodu ani nie może wprowadzić liczby ani niczego innego;
• Maksymalna długość kodu wynosi 100 bajtów.

Tabela liderów

1. Steven H. , Pyth ≈ f _{φ (1,0,0) +7} (256 ²⁶ ) / 1000000 ^[1]
2. Simply Beautiful Art , Ruby ≈ f _{φ 121 (ω)} (126) ^[1]
3. Peter Taylor , GolfScript ≈ f _{ε 0 + ω + 1} (17) / 1000 ^[1]
4. res , GolfScript ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))))) ^[1]
5. Simply Beautiful Art , Ruby ≈ f _{ω ^ω2 +1} (1983)
6. eaglgenes101 , Julia ≈ f _ω3 (127)
7. col6y , Python 3, ≈ (127 → 126 → ... → 2 → 1) / 99 ^{3 [1] [3]}
8. Toeofdoom Haskell, ≈ ₂₀ (1) / 99 ^{3 [1]}
9. Fraxtil , dc, ≈ 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15/100 ^{3 [3]}
10. Magenta , Python, (ack (126 126) / 100 ³ ≈ 10 ↑ ¹²⁴ 129
11. Kendall Frey , ECMAScript 6 ≈ 10 ^{3 ↑ 4 3} /100 ^{3 [1]}
12. Ilmari Karonen , GolfScript, ≈ 10 ↑ ³ 10 ³⁷⁷ /18 ^{3 [1]}
13. BlackCap , Haskell, ≈ 10 ↑↑ 65503/100 ³
14. rekurencyjny , Python, ≈ 2↑↑ 11/95 ³ ≈ 10 ↑↑ 8.63297 ^{[1] [3]}
15. nm , Haskell, ≈ 2↑↑ 7/100 ³ ≈ 10 ↑↑ 4.63297 ^[1]
16. David odchylenia , C ≈ 10 ^{10 4 X 10 22} /83 ³ ≈ 10 ↑↑ 4,11821 ^[2]
17. Primo , Perl ≈ 10 ^{(12750684161!) 5 x 2 27} /100 ³ ≈ 10 ↑↑ 4,11369
18. Sztuki , C ≈ 10 ^{10 2 x 10 6} /98 ³ ≈ 10 ↑↑ 3,80587
19. Robert Sørlie , x86, ≈ 10 ^{2 2 19 +32} / 100 ³ ≈ 10 ↑↑ 3,71585
20. Tobia , APL ≈ 10 ^{10 353} /100 ³ ≈ 10 ↑↑ 3,40616
21. Darren Stone , C, ≈ 10 ^{10 97,61735} / 98 ³ ≈ 10 ↑↑ 3.29875
22. ecksemmess , C ≈ 10 ^{2 320} /100 ³ ≈ 10 ↑↑ 3,29749
23. Adam Speight , vb.net, ≈ 10 ^{5000 x (2 64 ) 4} /100 ³ ≈ 10 ↑↑ 3,28039
24. Joshua , bash, ≈ 10 ^{10 15} /86 ³ ≈ 10 ↑↑ 3,07282

_Przypisy

1. ^{Gdyby każdy elektron we wszechświecie był kubitem, a każda jego superpozycja mogłaby być z korzyścią wykorzystywana do przechowywania informacji (co, o ile tak naprawdę nie trzeba wiedzieć, co jest przechowywane, jest teoretycznie możliwe), program ten wymaga więcej pamięci niż mógłby być może istnieją i dlatego nie można ich uruchomić - teraz ani w żadnym możliwym punkcie w przyszłości. Jeśli autor zamierzał wydrukować wartość większą niż ↑3 ↑↑ 3.28 jednocześnie, warunek ten ma zastosowanie.}
2. ^{Ten program wymaga więcej pamięci niż obecnie, ale nie tak bardzo, że teoretycznie nie mógłby być przechowywany na skąpej liczbie kubitów, dlatego też może kiedyś istnieć komputer, który mógłby uruchomić ten program.}
3. ^{Wszyscy obecnie dostępni tłumacze zgłaszają błąd w czasie wykonywania lub program nie działa inaczej, jak zamierzał autor.}
4. ^{Uruchomienie tego programu spowoduje nieodwracalne uszkodzenie systemu.}

Edytuj @primo : Zaktualizowałem część tablicy wyników, używając, mam nadzieję, łatwiejszego do porównania zapisu, z ułamkami dziesiętnymi, które oznaczają logarytmiczną odległość do następnej wyższej mocy. Na przykład 10 ↑↑ 2,5 = 10 ^{10 √10} . Zmieniłem również niektóre wyniki, jeśli uważałem, że analiza użytkownika jest wadliwa, możesz zakwestionować którąkolwiek z nich.

Objaśnienie tego zapisu:

Jeśli 0 ≤ b < 1tak .a↑↑b = ab

Jeśli b ≥ 1tak .a↑↑b = aa↑↑(b-1)

Jeśli b < 0tak .a↑↑b = loga(a↑↑(b+1))

GolfScript; ocena co najmniej f _{ε_0 + ω + 1} (17) / 1000

Zgodnie z sugestią Res , aby użyć odpowiedzi Lifetime robaka na to pytanie, przedstawiam dwa programy, które znacznie poprawiły jego pochodzenie rozwiązania Howarda.

Dzielą wspólny przedrostek, modulo nazwę funkcji:

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

oblicza, g(g(1)) = g(5)gdzie g(x) = worm_lifetime(x, [x])rośnie w przybliżeniu jako f _{ε 0} (co oznacza, że ​​„funkcja w szybko rosnącej hierarchii, która rośnie mniej więcej w tym samym tempie, co funkcja Goodsteina”).

Nieco łatwiej (!) Do analizy jest

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*mapy xdo foo^x x.

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

w ten sposób daje g^(g(5)) ( g(5) ); kolejne 8 poziomów iteracji jest podobne do tworzenia łańcuchów strzałek. Wyrażając się w prosty sposób: czy h_0 = gi h_{i+1} (x) = h_i^x (x)wtedy obliczamy h_10 (g(5)).

Myślę, że ten drugi program prawie na pewno osiąga znacznie lepsze wyniki. Tym razem etykieta przypisana do funkcji gjest znakiem nowej linii (sic).

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

Tym razem lepiej wykorzystam ^jako inną funkcję.

.['.{
}*'n/]*zip n*~

bierze xstos i opuszcza xciąg zawierający xkopie, .{a gnastępnie xkopie }*; następnie ocenia ciąg. Ponieważ miałem lepsze miejsce do wypalania zapasowych postaci, zaczynamy od j_0 = g; jeśli j_{i+1} (x) = j_i^x (x)to pierwsza ocena ^obliczeń j_{g(5)} (g(5))(co jestem prawie pewien, że już wygrywa z poprzednim programem). Następnie wykonuję jeszcze ^16 razy; więc jeśli k_0 = g(5)i k_{i+1} = j_{k_i} (k_i)to się liczy k_17. Jestem wdzięczny (ponownie) res za oszacowanie tego k_i>> f _{ε_0 + ω + 1} (i).

Windows 2000 - Windows 8 (3907172 / 23³ = 321)

UWAGA: NIE URUCHAMIAJ TEGO!

Zapisz następujące elementy w pliku wsadowym i uruchom go jako Administrator.

CD|Format D:/FS:FAT/V/Q

Wyjście jest uruchamiane na napędzie 4 TB z pierwszym wydrukowanym numerem pogrubionym drukiem.

Włóż nowy dysk do napędu D:
i naciśnij klawisz ENTER, gdy będzie gotowy ... Typ systemu plików to NTFS.
Nowym systemem plików jest FAT.
Szybkie formatowanie 3907172M
Głośność jest za duża dla FAT16 / 12.

GolfScript, wynik: droga zbyt dużo

OK, jak dużą liczbę możemy wydrukować w kilku znakach GolfScript?

Zacznijmy od następującego kodu ( dzięki, Ben! ), Który drukuje 126:

'~'(

Następnie powtórzmy to 126 razy, dając nam liczbę równą około 1,26126 × 10 ³⁷⁷ :

'~'(.`*

(To powtarzanie ciągów, a nie mnożenie, więc zgodnie z zasadami powinno być OK.)

Powtórzmy teraz tę 378-cyfrową liczbę nieco ponad 10 ³⁷⁷ razy:

'~'(.`*.~*

Nigdy nie zobaczysz zakończenia tego programu, ponieważ próbuje on obliczyć liczbę z około 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ cyfr. Żaden komputer, który kiedykolwiek zbudowano, nie byłby w stanie pomieścić tak dużej liczby, ani taki komputer nigdy nie mógłby zostać zbudowany przy użyciu znanej fizyki; liczba atomów w obserwowalnego Wszechświata szacuje się na około 10 ⁸⁰ , więc nawet jeśli moglibyśmy jakoś wykorzystać całą materię we Wszechświecie przechowywać tę ogromną liczbę, byśmy nadal jakoś trzeba napełnić około 10 ³⁸⁰ /10 ⁸⁰ = 10 ³⁰⁰ cyfr w każdym atomie!

Załóżmy jednak, że mamy własnego Boskiego interpretera GolfScript, który jest w stanie przeprowadzić takie obliczenia i że nadal nie jesteśmy zadowoleni. OK, zróbmy to jeszcze raz!

'~'(.`*.~*.~*

Dane wyjściowe tego programu, jeśli mogłyby zostać ukończone, miałyby około 10 ^{10 383} cyfr, a więc byłyby równe około 10 ^{10 10 383} .

Ale poczekaj! Ten program zaczyna się powtarzać ... dlaczego nie zmienimy go w pętlę?

'~'(.`*.{.~*}*

Tutaj ciało pętli biegnie około 10 ³⁷⁷ razy, dając nam teoretyczny wynik składający się z około 10 ^{10⋰ 10 377} cyfr lub więcej, gdzie wieża o iterowanych mocach 10 ma około 10 ³⁷⁷ kroków. (W rzeczywistości jest to rażące niedoszacowanie, ponieważ zaniedbuję fakt, że powtarzana liczba również się wydłuża za każdym razem, ale mówiąc relatywnie rzecz biorąc, jest to niewielki problem.)

Ale jeszcze nie skończyliśmy. Dodajmy kolejną pętlę!

'~'(.`*.{.{.~*}*}*

Nawet prawidłowe zapisanie przybliżenia takich liczb wymaga ezoterycznej notacji matematycznej. Na przykład, w notacji Knutha , liczba (teoretycznie) wynikająca z powyższego programu powinna wynosić około 10 ↑ ³ 10 ³⁷⁷ , dać lub wziąć kilka (lub 10 ³⁷⁷ ) potęg dziesięciu, zakładając, że zrobiłem matematykę poprawnie.

Liczby takie jak ta przekraczają po prostu „niewiarygodnie ogromne” i wkraczają w sferę „niepojętych”. Podobnie jak w przypadku, nie tylko nie można policzyć ani zapisać takich liczb (przekroczyliśmy ten punkt już w trzecim przykładzie powyżej), ale dosłownie nie mają one żadnego możliwego zastosowania ani istnienia poza abstrakcyjną matematyką. Możemy udowodnić, z aksjomatów matematyki , że istnieją takie liczby, jak możemy udowodnić ze specyfikacji GolfScript tego programu ponad byłoby je obliczyć, jeśli granice rzeczywistości i dostępnej przestrzeni magazynowej nie interweniować), ale nie ma dosłownie nic w fizyczny wszechświat, którego moglibyśmy użyć do policzenia lub pomiaru w dowolnym sensie.

Mimo to matematycy czasami używają jeszcze większych liczb . (Teoretycznie) obliczanie tak dużych liczb wymaga nieco więcej pracy - zamiast po prostu zagnieżdżać więcej pętli jeden po drugim, musimy użyć rekurencji do teleskopowania głębokości zagnieżdżonych pętli. Jednak w zasadzie powinno być możliwe napisanie krótkiego programu GolfScript (spodziewałbym się, że poniżej 100 bajtów) (teoretycznie) obliczy dowolną liczbę możliwą do wyrażenia, powiedzmy, w notacji łańcuchowej Conwaya ; szczegóły pozostawia się jako ćwiczenie. ;-)

JavaScript 44 znaki

To może wydawać się trochę oszukiwane:

alert((Math.PI+''+Math.E).replace(/\./g,""))

Wynik = 31415926535897932718281828459045/44 ^ 3 ≈ 3,688007904758867e + 26 ≈ 10 ↑↑ 2,1536134004

C, wynik = 10 ^{10 97,61735} / 98 ³ ≈ 10 ↑↑ 2.29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

Doceniam pomoc w punktacji. Wszelkie spostrzeżenia i poprawki są mile widziane. Oto moja metoda:

n = konkatenacja każdej liczby od 1 do 2 ⁶⁴ -1, powtórzona (2 ⁶⁴ -1) ⁴ razy . Po pierwsze, oto w jaki sposób szacuję (małą) łączną liczbę cyfr od 1 do 2 ⁶⁴ -1 („podsekwencja”): Ostateczna liczba w sekwencji podsekwencji wynosi 2 ⁶⁴ -1 = 18446744073709551615z 20 cyframi. Tak więc ponad 90% liczb w podsekwencji (te zaczynające się od 1.. 9) ma 19 cyfr. Załóżmy, że pozostałe 10% to średnio 10 cyfr. Będzie to znacznie więcej, ale jest to niska ocena dla łatwej matematyki i bez oszukiwania. Ta podsekwencja jest powtarzana (2 ⁶⁴ -1) ⁴ razy, więc długośćz n będzie wynosić co najmniej (0,9 × (2 ⁶⁴ -1) × 19 + 0,1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = 3,86613 × 10 ⁹⁷ cyfr. W poniższych komentarzach @primo potwierdza, że n wynosi 4,1433x10 ⁹⁷ . Zatem n samo będzie miało 10 do tej potęgi, czyli 10 ^{10 97,61735} .

l = 98 znaków kodu

wynik = n / l ³ = 10 ^{10 97,61735} / 98 ³

Wymagania: Musi działać na komputerze 64-bitowym, gdzie sizeof(long) == 8. Mac i Linux to zrobią.

Python 3 - 99 znaków - (najprawdopodobniej) znacznie większy niż liczba Grahama

Wymyśliłem szybciej rosnącą funkcję opartą na rozszerzeniu funkcji Ackermanna.

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

Inspiruje mnie http://fora.xkcd.com/viewtopic.php?f=17&t=31598 , ale nie musisz tam szukać, aby zrozumieć mój numer.

Oto zmodyfikowana wersja funkcji ackermann, której będę używać w mojej analizie:

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

Moja funkcja Aw powyższym kodzie nie jest technicznie taka sama, ale w rzeczywistości jest silniejsza, z następującą instrukcją zastępującą trzeci wiersz powyższej definicji:

A(a,0,...)=A(a-1,a,...)

(a musi wynosić co najmniej 1, więc musi być silniejsze)

Ale dla moich celów założę, że jest taki sam jak ten prostszy, ponieważ analiza jest już częściowo wykonana dla funkcji Ackermanna, a zatem dla tej funkcji, gdy ma dwa argumenty.

Moja funkcja ostatecznie przestanie się powtarzać, ponieważ zawsze albo: usuwa argument, zmniejsza pierwszy argument, albo zachowuje ten sam pierwszy argument i zmniejsza drugi argument.

Analiza wielkości

Numer Grahama, AFAIK, można przedstawić jako G(64):

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

Gdzie ↑^(n)b jest notacją Knutha skierowaną w górę.

Także:

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

Liczba wyrażona w powyższym programie to A(0,1,2,3,4,...,123,124,125).

Ponieważ g^64(4)jest to liczba Grahama i przy założeniu, że moja matematyka jest poprawna, to jest mniejsza niż A(1,64,100), moja liczba jest znacznie większa niż liczba Grahama.

Proszę wskazać wszelkie błędy w mojej matematyce - chociaż jeśli nie ma, powinna to być największa jak dotąd liczba obliczona, aby odpowiedzieć na to pytanie.

Perl - wynik ≈ 10 ↑↑ 4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Po raz kolejny nadużywam silnika wyrażeń regularnych Perla do mielenia niewyobrażalnej ilości kombinacji, tym razem przy użyciu rekurencyjnego zejścia.

W wewnętrznej części wyrażenia mamy dość, .aby zapobiec nieskończonej rekurencji, a tym samym ograniczyć poziomy rekurencji do długości łańcucha.

Skończymy z tym:

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... powtórzyłem 671088640 razy, w sumie 12750684161 zagnieżdżeń - co całkiem dokładnie zawstydza moją poprzednią próbę 23 zagnieżdżeń. Co dziwne, perl nawet się nie dusi (po raz kolejny zużycie pamięci utrzymuje się na stałym poziomie około 1,3 GB), chociaż upłynie sporo czasu, zanim wydane zostanie pierwsze polecenie wydruku.

Od mojej poprzedniej analizie poniżej, można stwierdzić, że liczba cyfr wyjściem będzie rzędu (! 12750684161) ^671088640 , gdzie ! K jest Lewy Silnia z k (patrz A003422 ). Możemy to przybliżać jako (k-1)! , który jest ściśle mniejszy, ale tego samego rzędu wielkości.

A jeśli zapytamy wolframalpha :

... co ledwo zmienia mój wynik. Myślałem na pewno, że będzie to co najmniej 10 ↑↑ 5 . Myślę, że różnica między 10 ↑↑ 4 a 10 ↑↑ 4.1 jest znacznie większa, niż mogłoby się wydawać.

Perl - wynik ≈ 10 ↑↑ 4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

Nadużywanie silnika wyrażeń regularnych Perla, aby zrobić dla nas kombinatorykę. Osadzony blok kodu
(??{print})wstawi wynik bezpośrednio do wyrażenia regularnego. Ponieważ $_składa się wyłącznie z 2s (a wynikiem printjest zawsze 1), to nigdy nie może się równać, i wysyła perl wirujący przez wszystkie możliwe kombinacje, z których jest całkiem sporo.

Zastosowane stałe

• $^F- zazwyczaj maksymalny uchwyt pliku systemowego 2.
• $]- numer wersji perla, podobny do 5.016002.

$_jest wówczas ciągiem zawierającym cyfrę 2powtórzoną 671088640 razy. Zużycie pamięci jest stałe przy około 1,3 GB, wyjście rozpoczyna się natychmiast.

Analiza

Zdefiniujmy P _k (n) jako liczbę wykonań instrukcji print, gdzie k jest liczbą zagnieżdżeń, a n jest długością ciągu plus jeden (tylko dlatego, że nie mam ochoty pisać n + 1 wszędzie).

(.*.*)*
P ₂ (n) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

((.*.*)*)*
P ₃ (n) = [ 3, 18, 123, 900, 6693, 49926, 372615, 2781192, ... ]

(((.*.*)*)*)*
P ₄ (n) = [ 4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ... ]

((((.*.*)*)*)*)*
P ₅ (n) = [ 5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ... ]

(((((.*.*)*)*)*)*)*
P ₆ (n) = [ 6, 1452, 445698, 137050584, 42142941390, 12958920156996, ... ]

((((((.*.*)*)*)*)*)*)*
P ₇ (n) = [ 7, 10094, 17634981, 30817120348, 53852913389555, ... ]

itp. Ogólnie formułę można uogólnić w następujący sposób:

gdzie

Oznacza to, że lewa Silnia od k , czyli sumy wszystkich silni mniej niż k (patrz A003422 ).

Byłem w stanie określić, zamknięte formy dla D _K i E _k , ale to nie ma znaczenia zbyt wiele, jeśli widzimy, że

i

Przy 23 zagnieżdżeniach daje nam to przybliżony wynik:

To powinno być prawie dokładne.

Ale aby umieścić to w notacji, która jest nieco łatwiejsza do wizualizacji, możemy przybliżyć podstawę wewnętrznego wykładnika:

a następnie sam wykładnik:

a następnie zapytaj wolframalpha :

który równie dobrze możesz po prostu zadzwonić 10 ↑↑ 4 i skończyć z tym.

JavaScript, 10 ↑↑↑↑ 210

100 znaków:

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

Opierając się na spostrzeżeniu, że foptymalnym rozwiązaniem jest maksymalne iterowanie , zastąpiłem 13 wywołań f3 poziomami wywoływania zagnieżdżonych pętli f, zrazy za każdym razem ( fciągle się zwiększając z).

Oceniłem wynik analitycznie na kartce papieru - napiszę go, jeśli ktoś będzie zainteresowany jego zobaczeniem.

Poprawiony wynik: 10 ↑↑ 13

JavaScript, dokładnie w 100 znakach, znowu:

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

To poprawia moją pierwotną odpowiedź na trzy sposoby -

1. Zdefiniowanie zzakresu globalnego pozwala nam uniknąć konieczności pisania za o.zkażdym razem.

2. Możliwe jest zdefiniowanie gettera w zasięgu globalnym (okno) i wpisanie fzamiast o.f.

3. Posiadanie większej liczby iteracji fjest warte więcej niż rozpoczynanie od większej liczby, więc zamiast (Math.E+'').replace('.','')(= 2718281828459045, 27 znaków) lepiej jest użyć ~~Math.E+''(= 2, 11 znaków) i używać uratowanych znaków, aby dzwonić fwiele razy.

Ponieważ, jak przeanalizowano poniżej, każda iteracja daje, z liczby w rzędzie wielkości M , większą liczbę w rzędzie wielkości 10 ^M , kod ten powstaje po każdej iteracji

1. 210 ∼ O (10 ² )
2. O (10 ^{10 2} ) ∼ O (10 ↑↑ 2)
3. O (10 ^{10 ↑↑ 2} ) = O (10 ↑↑ 3)
4. O (10 ^{10 ↑↑ 3} ) = O (10 ↑↑ 4)
5. O (10 ^{10 ↑↑ 4} ) = O (10 ↑↑ 5)
6. O (10 ^{10 ↑↑ 5} ) = O (10 ↑↑ 6)
7. O (10 ^{10 ↑↑ 6} ) = O (10 ↑↑ 7)
8. O (10 ^{10 ↑↑ 7} ) = O (10 ↑↑ 8)
9. O (10 ^{10 ↑↑ 8} ) = O (10 ↑↑ 9)
10. O (10 ^{10 ↑↑ 9} ) = O (10 ↑↑ 10)
11. O (10 ^{10 ↑↑ 10} ) = O (10 ↑↑ 11)
12. O (10 ^{10 ↑↑ 11} ) = O (10 ↑↑ 12)
13. O (10 ^{10 ↑↑ 12} ) = O (10 ↑↑ 13)

Wynik: ∼10 ^{10 10 10 10 16} ≈ 10 ↑↑ 6.080669764

JavaScript, dokładnie 100 znaków:

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

Każde o.fwywołuje pętlę while, co daje w sumie 5 pętli. Już po pierwszej iteracji wynik jest już ponad 10 ^{42381398144233621} . W drugiej iteracji Mathematica nie był w stanie obliczyć nawet liczby cyfr w wyniku.

Oto przewodnik po kodzie:

W tym

Zacznij od 2718281828459045, usuwając przecinek dziesiętny z Math.E.

Iteracja 1

Połącz malejącą sekwencję liczb,

• 2718281828459045
• 2718281828459044
• 2718281828459043
• ...
• 3)
• 2)
• 1
• 0

aby utworzyć nowy (gigantyczny) numer,

• 271828182845904527182818284590442718281828459043 ... 9876543210.

Ile cyfr jest w tym numerze? Cóż, to jest konkatenacja

• 1718281828459046 16-cyfrowe liczby
• 900000000000000 15-cyfrowe numery
• 90000000000000 14-cyfrowe numery,
• 9000000000000 13-cyfrowe numery
• ...
• 900 3-cyfrowych liczb
• 90 2-cyfrowych liczb
• 10 1-cyfrowych liczb

W Mathematica

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

Innymi słowy, jest to 2,72⋅10 ^{42381398144233625} .

Robiąc mój wynik, już po pierwszej iteracji, 2.72⋅10 ^{42381398144233619} .

Iteracja 2

Ale to dopiero początek. Teraz powtórz kroki, zaczynając od gigantycznej liczby ! To znaczy, łączymy malejącą sekwencję liczb,

• 271828182845904527182818284590442718281828459043 ... 9876543210
• 271828182845904527182818284590442718281828459043 ... 9876543209
• 271828182845904527182818284590442718281828459043 ... 9876543208
• ...
• 3)
• 2)
• 1
• 0

Jaki jest mój nowy wynik, Mathematica?

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

Iteracja 3

Powtarzać.

Iteracja 4

Powtarzać.

Iteracja 5

Powtarzać.

Wynik analityczny

W pierwszej iteracji obliczono liczbę cyfr w konkatenacji malejącej sekwencji rozpoczynającej się od 2718281828459045, zliczając liczbę cyfr w

• 1718281828459046 16-cyfrowe liczby
• 900000000000000 15-cyfrowe numery
• 90000000000000 14-cyfrowe numery,
• 9000000000000 13-cyfrowe numery
• ...
• 900 3-cyfrowych liczb
• 90 2-cyfrowych liczb
• 10 1-cyfrowych liczb

Suma ta może być reprezentowana przez wzór,

gdzie Z oznacza liczbę początkową ( np. 2718281828459045), a O _Z oznacza jego rząd wielkości ( np. 15, ponieważ Z ∼ 10 ¹⁵ ). Używając równoważników dla sum skończonych , powyższe można wyrazić wprost jako

co, jeśli weźmiemy 9 ≈ 10, zmniejsza się jeszcze bardziej do

i wreszcie, poszerzanie warunków i porządkowanie ich poprzez zmniejszanie rzędu wielkości, otrzymujemy

Ponieważ interesuje nas tylko rząd wielkości wyniku, zastąpmy Z „liczbą w rzędzie wielkości O _Z ”, tj. 10 ^{O _Z} -

Wreszcie, drugi i trzeci termin zostają anulowane, a ostatnie dwa terminy można usunąć (ich rozmiar jest trywialny), co pozostawia nam

od którego wygrywa pierwszy semestr.

Przekształcone, fprzyjmuje liczbę rzędu wielkości M i daje liczbę w przybliżeniu rzędu wielkości M (10 ^M ).

Pierwszą iterację można łatwo sprawdzić ręcznie. 2718281828459045 to liczba rzędu wielkości 15 - dlatego fpowinna dać liczbę rzędu wielkości 15 (10 ¹⁵ ) ∼ 10 ¹⁶ . Rzeczywiście, wyprodukowana liczba wynosi z góry 2,72⋅10 ^{42381398144233625} - czyli 10 ^{42381398144233625} 6 ^{10 10 16} .

Biorąc pod uwagę, że M nie jest znaczącym czynnikiem w M (10 ^M ), rząd wielkości wyniku każdej iteracji następuje zatem według prostego wzoru tetracji:

1. 10 ¹⁶
2. 10 ^{10 16}
3. 10 ^{10 10 16}
4. 10 ^{10 10 10 16}
5. 10 ^{10 10 10 10 16}

Źródła LaTeX

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

APL, 10 ↑↑ 3.4

Oto moja zmieniona próba:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

Program 100 znaków / bajt *, działający na bieżącym sprzęcie (zużywa niewielką ilość pamięci i zwykłe 32-bitowe zmienne int), chociaż jego ukończenie zajmie bardzo dużo czasu.

Możesz go uruchomić na interprecie APL i zacznie drukować cyfry. Jeśli pozwolisz na wypełnienie, wydrukuje liczbę z 10 × 123456789 ⁴⁴ cyframi.

Dlatego wynik wynosi 10 ^{10 x 123456789 44} /100 ³ ≈ 10 ^{10 353} ≈ 10 ↑↑ 3,406161

Wyjaśnienie

• ⎕D jest predefiniowanym ciągiem ciągłym równym '0123456789'
• n←⍎⎕Ddefiniuje n jako liczbę reprezentowaną przez ten ciąg: 123456789 (która jest <2 ³¹ i dlatego może być używana jako zmienna sterująca pętli)
• {⍞←⎕D} wypisze 10 cyfr na standardowe wyjście, bez nowego wiersza
• {⍞←⎕D}⍣nzrobi to n razy ( ⍣jest „operatorem mocy”: to nie jest *, /, ani ^, ponieważ nie jest to operacja matematyczna, to rodzaj pętli)
• {⍞←n}⍣n⍣npowtórzy poprzednią operację n razy, dlatego drukuje 10 cyfr n ² razy
• {⍞←n}⍣n⍣n⍣nzrobi to n ³ razy
• Mógłbym tam zmieścić 44 ⍣n, więc drukuje n ⁴⁴ razy ciąg '0123456789'.

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: APL można zapisać we własnym (starszym) jednobajtowym zestawie znaków, który odwzorowuje symbole APL na górne 128 bajtów. Dlatego do celów oceniania program N znaków, który używa tylko znaków ASCII i symboli APL, może zostać uznany za N-bajtowy.}

Haskell, wynik: (2 ^{2 2 65536-3} ) / 1000000 ≈ 2 ↑↑ 7 ≈ 10 ↑↑ 4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

Ten program ma dokładnie 100 bajtów czystego kodu Haskell. Wypisze czwartą liczbę Ackermanna, ostatecznie zużywając w tym procesie całą dostępną energię, materię i czas Wszechświata (i dalej) ( nieznacznie przekraczając miękki limit 5 sekund).

Python, 2 ↑↑ 11/830584 ≈ 10 ↑↑ 8.632971 (Notacja strzałki w górę Knutha)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

Prawdopodobnie żaden komputer nie ma wystarczającej ilości pamięci, aby pomyślnie to uruchomić, ale tak naprawdę nie jest to wina programu. Przy spełnieniu minimalnych wymagań systemowych działa.

Tak, to trochę przesuwa wartości logiczne. Truezostaje do 1tego zmuszony . Python ma liczby całkowite o dowolnej długości.

GolfScript 3.673e + 374

'~'(.`*

Myślę, że *jest to dozwolone, ponieważ oznacza powtarzanie ciągów, a nie mnożenie.

Objaśnienie: '~'(pozostawi 126 (wartość ASCII „~”) na stosie. Następnie skopiuj liczbę, przekonwertuj ją na ciąg i powtórz ciąg 126 razy. To daje w 126126126126...przybliżeniu 1.26 e+377. Rozwiązanie składa się z 7 znaków, więc podziel przez 7^3, aby uzyskać wynik około3.673e+374

Rubinowy, probabilistycznie nieskończony, 54 znaki

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

x jest inicjowany na 97. Następnie iterujemy następującą procedurę: Wygeneruj x liczb losowych od 0 do 1. Jeśli wszystkie są takie same, zakończ i wypisz x. W przeciwnym razie dwukrotnie x i powtórz. Ponieważ losowe liczby Ruby mają 17 cyfr dokładności, szanse na zakończenie każdego kroku wynoszą 1 na (10e17) ^ x. Prawdopodobieństwo zakończenia w ciągu n kroków jest zatem sumą dla x = 1 do n (1 / 10e17) ^ (2 ^ n), która jest zbieżna do 1 / 10e34. Oznacza to, że dla dowolnej liczby, bez względu na to, jak duże, jest w przeważającej mierze mało prawdopodobne, że ten program wyświetli mniejszą liczbę.

Oczywiście, filozoficznym pytaniem jest, czy program, który ma mniej niż 1 na 10 ^ 34 szansę na zakończenie kroku n dla dowolnego n, można powiedzieć, że kiedykolwiek się zakończy. Jeśli założymy nie tylko nieskończony czas i moc, ale że program ma możliwość działania z rosnącą prędkością z prędkością przekraczającą szybkość, z którą maleje prawdopodobieństwo zakończenia, możemy, jak sądzę, faktycznie ustalić prawdopodobieństwo kończące się w czasie t arbitralnie bliskie 1.

GolfScript, ≈ f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))))))

Jest to bezwstydnie dostosowane z innej odpowiedzi @Howard i zawiera sugestie @Peter Taylor.

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

Moje rozumienie GolfScript jest ograniczone, ale uważam, że powyższe operatory *i nie^ są operatorami arytmetycznymi zabronionymi przez OP.

(Z przyjemnością usunę to, jeśli @Howard chce przesłać własną wersję, która i tak bez wątpienia byłaby lepsza od tej.)

Ten program oblicza liczbę w przybliżeniu f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (f _{ε 0} (126)))))) ))) - dziewięciokrotna iteracja f _{ε 0} - gdzie f _{ε 0} jest funkcją w szybko rosnącej hierarchii, która rośnie mniej więcej w tym samym tempie co funkcja Goodsteina. (f _{ε 0}rośnie tak szybko, że tempo wzrostu funkcji n (k) Friedmana i k-krotnych strzały łańcuchowe Conwaya są praktycznie nieistotne, nawet w porównaniu z pojedynczym nie iterowanym f _{ε 0.} )

dc, 100 znaków

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

Biorąc pod uwagę wystarczającą ilość czasu i pamięci, obliczymy liczbę około 15 ↑ ¹⁶⁶⁶⁶⁶⁵ 15. Pierwotnie zaimplementowałem funkcję hiperoperacji , ale wymagało to zbyt wielu znaków do tego wyzwania, więc usunąłem warunki n = 2, b = 0i n >= 3, b = 0, zamieniając n = 1, b = 0warunek n >= 1, b = 0.

Jedynymi używanymi tutaj operatorami arytmetycznymi są dodawanie i odejmowanie.

EDYCJA: zgodnie z obietnicą w komentarzach, oto podział tego, co robi ten kod:

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

Jak zauważono, różni się to od funkcji hiperoperacji tym, że podstawowe przypadki mnożenia i wyższe są zastępowane przez podstawowe przypadki dodawania. Ten kod zachowuje się tak, jakby a*0 = a^0 = a↑0 = a↑↑0 ... = azamiast matematycznie poprawnego a*0 = 0i a^0 = a↑0 = a↑↑0 ... = 1. W rezultacie oblicza wartości, które są nieco wyższe niż powinny, ale to nie jest wielka sprawa, ponieważ dążymy do większych liczb. :)

EDYCJA: Właśnie zauważyłem, że cyfra przypadkowo wślizgnęła się do kodu w makrze, które wykonuje przyrosty n=0. Usunąłem go, zastępując go „F” (15), co powoduje efekt uboczny skalowania każdej operacji przyrostowej o 15. Nie jestem pewien, jak bardzo wpływa to na końcowy wynik, ale prawdopodobnie jest teraz znacznie większy.

Nie ma już limitu czasu działania? OK.

Czy program musi być uruchamiany na nowoczesnych komputerach?

Oba rozwiązania wykorzystują 64-bitową kompilację, więc longjest to 64-bitowa liczba całkowita.

C: większa niż 10 ^{(2 64 -1) 2 64} , która sama jest większa niż 10 ^{10 355393490465494856447} ≈ 10 ↑↑ 4.11820744

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88 znaków.

Aby ułatwić te formuły, użyję t = 2^64-1 = 18446744073709551615.

mainbędzie wywoływał fz parametrem t, który zapętli tczasy, za każdym razem drukując wartość ti wywołując fz parametrem t-1.

Wszystkich cyfry wydrukowane: 20 * t.

Każde z tych wywołań fz parametrem t-1iteruje tczasy, wypisuje wartość ti wywołuje f z parametrem t-2.

Liczba wydrukowanych cyfr: 20 * (t + t*t)

Wypróbowałem ten program, używając odpowiednika 3-bitowych liczb całkowitych (ustawiłem i = 8i miałem wywołanie główne f(7)). Uderzył w drukowany wyciąg 6725600 razy. To się sprawdza, 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7dlatego uważam, że jest to ostateczna liczba dla pełnego programu:

Liczba wydrukowanych cyfr: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

Nie jestem pewien, jak obliczyć (2 ⁶⁴ -1) ^{2 64} . To sumowanie jest mniejsze niż (2 ⁶⁴ ) ^{2 64} , a do obliczeń potrzebuję potęgi dwóch. Dlatego obliczę (2 ⁶⁴ ) ^{2 64 -1} . Jest mniejszy niż rzeczywisty wynik, ale ponieważ jest potęgą dwóch, mogę przekonwertować go na potęgę 10 dla porównania z innymi wynikami.

Czy ktoś wie, jak wykonać to sumowanie lub jak przekonwertować (2 ⁶⁴ -1) ^{2 64} na 10 ⁿ ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
podziel ten wykładnik przez logarytmiczną podstawę 2 z 10, aby przełączyć podstawę wykładnika na potęgi 10.
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

Pamiętaj jednak, że to liczba wydrukowanych cyfr. Wartość liczby całkowitej wynosi 10 podniesiona do tej potęgi, więc 10 ^ 10 ^ 355393490465494856447

Ten program będzie miał głębokość stosu 2 ^ 64. To 2 ^ 72 bajty pamięci tylko do przechowywania liczników pętli. To 4 miliardy terabajtów liczników pętli. Nie wspominając o innych rzeczach, które trafiłyby na stos dla 2 ^ 64 poziomów rekurencji.

Edycja: Poprawiono parę literówek i użyłem bardziej precyzyjnej wartości dla log2 (10).

Edycja 2: Zaczekaj sekundę, mam pętlę, której printf jest poza. Naprawmy to. Dodano inicjalizację i.

Edycja 3: Cholera, zepsułem matematykę z poprzedniej edycji. Naprawiony.

Ten będzie działał na nowoczesnych komputerach, ale wkrótce się nie skończy.

C: 10 ^ 10 ^ 136 ≈ 10 ↑↑ 3,329100567

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

98 znaków.

Spowoduje to wydrukowanie odwrotności bitowej zera, 2 ^ 64-1, raz dla każdej iteracji. 2 ^ 64-1 to 20 cyfr.

Liczba cyfr = 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187500

Zaokrąglenie długości programu do 100 znaków, Wynik = liczba wydrukowana / 1 000 000

Wynik = 10 ^ 14536774485912137805470195290264863598250876154813037507443495139872713780096227571027903270680672445638775618778303705182042800542187494

R - 49 41 znaków kodu, 4.03624169270483442 * 10 ^ 5928 ≈ 10 ↑↑ 2.576681348

set.seed(T)
cat(abs(.Random.seed),sep="")

wydrukuje [powielając tutaj dopiero początek]:

403624169270483442010614603558397222347416148937479386587122217348........

ECMAScript 6 - 10 ^ 3 ↑↑↑↑ 3/884736

(3 ↑↑↑↑ 3 to G (1) gdzie G (64) to liczba Grahama)

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

Wyjście: 10 ^ 3 ↑↑↑↑ 3

Poradnik:

Gto funkcja, w której G (64) jest liczbą Grahama. Dane wejściowe są liczbami całkowitymi. Dane wyjściowe to ciąg jednoargumentowy zapisany za pomocą 0. Usunięty dla zwięzłości.

Kto funkcja strzałki w górę Knutha a ↑ ⁿ b, gdzie a jest niejawnie 3. Dane wejściowe to n, łańcuch jednoargumentowy ib, łańcuch jednoargumentowy. Dane wyjściowe to ciąg jednoargumentowy.

u to „1”.

v to „0000” lub G (0)

e to „000”.

do

(Z przeprosinami dla Darrena Stone'a)

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

n = 2 ^ 64 cyfry (9 ...)

l = 100 znaków kodu

wynik ≈ 1e + 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936570 ≈ 10 ↑↑ 3.2974890744

[Wynik = n ^ 5 / l ^ 3 = (10 ^ (2 ^ 320) -1) / (100 ^ 3) = (10 ^ 2135987035920910082395021706169552114602704522356652769947041607822219725780640550022962086936576-1) / (10 ^ 6)]

Zauważ, że zasługuję na to, by bezlitośnie chłostać się za tę odpowiedź, ale nie mogłem się oprzeć. Z oczywistych powodów nie polecam zachowywać się tak jak ja podczas wymiany stosów. :-P

EDYCJA: Jeszcze trudniej oprzeć się pokusie pójścia z czymś takim

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

... ale przypuszczam, że zamierzoną, ale nieokreśloną zasadą było, że cały ciąg cyfr tworzących liczbę musi zostać wydrukowany.

Nowy Rubin: wynik ~ f _{ω ^ω2 +1} (126 ² 2 ¹²⁶ )

gdzie f _α (n) jest szybko rosnącą hierarchią.

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

Wypróbuj online!

Są *nto tylko mnożenie łańcuchów i tablic, więc powinny być w porządku.

Nieskluczony kod:

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

gdzie b.-b<=>0zwraca liczbę całkowitą 1bliższą 0niż b.

Wyjaśnienie:

Drukuje nna początku każdego połączenia H.

H[[]]podwaja się n( nrazy), tj n = n<<n.

H[[0,a,b,c,...,z]]połączenia H[[a,b,c,...,z]]( nczasy).

H[[k+1,a,b,c,...,z]]połączenia H[[k]*n+[a,b,c,...,z]]( nczasy), gdzie [k]*n = [k,k,...,k].

H[[-1,a,b,c,...,z]]połączenia H[[n]*n+[a,b,c,...,z]]( nczasy).

H[[-(k+1),a,b,c,...,z]]połączenia H[[-k]*n+[a,b,c,...,z]]( nczasy).

H[k] = H[[k]].

Mój program inicjuje się n = 126, a następnie wywołuje H[-n-1]126 ² 2 ¹²⁶ razy.

Przykłady:

H[[0]]zadzwoni, H[[]]co dotyczy n = n<<n( nrazy).

H[[0,0]]zadzwoni H[[0]]( nrazy).

H[[1]]zadzwoni H[[0]*n]( nrazy).

H[[-1]]zadzwoni H[[n]*n]( nrazy).

H[[-1,-1]]zadzwoni H[[n]*n+[-1]]( nrazy).

H[[-3]]zadzwoni H[[-2]*n]( nrazy).

Wypróbuj online!

Zobacz wersje innych fajnych rzeczy.

Haskell - funkcja Ackermanna zastosowana do jej wyniku 20 razy - 99 znaków

Jest to najlepsze rozwiązanie Haskell, jakie mogę wymyślić w oparciu o funkcję ackermann - możesz zauważyć pewne podobieństwa do rozwiązania nm, zainspirowany został i = round $ log pi, a reszta to zbieg okoliczności: D

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

Działa na sobie funkcję ackermann 20 razy, zaczynając od jednego, przy czym sekwencja jest

• 1,
• 3,
• 61,
• a (61,61),
• a (a ( 61, 61), a (61, 61) ) --- nazwiemy to ₂ (61) lub ₄ (1) ---
• a ₃ (61)
• ...
• ₁₈ (61), lub ₂₀ (1). Myślę, że jest to w przybliżeniu g ₁₈ (patrz poniżej).

Jeśli chodzi o szacunki, wikipedia mówi:

a (m, n) = 2 ↑ ^m-2 (n + 3) - 3

Z tego wynika, że ​​a3 (1) = a (61,61) = 2 ↑ ⁵⁹ 64 + 3, co jest wyraźnie większe niż g1 = 3 ↑ ⁴ 3, chyba że 3 na początku jest znacznie ważniejsze niż myślę. Następnie, każdy poziom nie następuje (odrzucając nieznacznych stałych w a _n )

• g _n = 3 ↑ ^{g _n-1} 3
• a _n ~ = 2 ↑ ^{a _n-1} (a _n-1 )

Jeśli są one w przybliżeniu równoważne, wówczas ₂₀ (1) ~ = g ₁₈ . Ostateczny składnik w _n , (a _n-1 ) jest znacznie większy niż 3, więc potencjalnie jest wyższy niż g ₁₈ . Zobaczę, czy uda mi się dowiedzieć, czy to przyspieszy choćby jedną iterację, i przekażę raport.

kod maszynowy x86 - 100 bajtów (złożony jako plik MSDOS .com)

Uwaga: może nieco zgiąć reguły

Ten program wyświetli 2 ^{(65536 * 8 + 32)} dziewiątek, co dałoby wynik na (10 ^{2 524320} -1) / 1000000

Jako licznik ten program wykorzystuje cały stos (64 kB) oraz dwa rejestry 16-bitowe

Zmontowany kod:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

Montaż:

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

do

Rozmiar pliku to 45 bajtów.

Program to:

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

Wyprodukowana liczba jest większa niż 10 ^ (10 ^ (10 ^ 1.305451600608433)).

Plik, do którego przekierowałem standardowe wyjście, ma obecnie ponad 16 Gb i wciąż rośnie.

Program zakończyłby się w rozsądnym czasie, gdybym miał lepszy komputer.

Mój wynik jest niepoliczalny z zmiennoprzecinkową podwójną precyzją.

GNU Bash, 10 ^ 40964096² / 80 ^ 3 ≈ 10 ↑↑ 2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

C = 4096 w dowolnym rozsądnym systemie. SHLVL jest małą dodatnią liczbą całkowitą (zwykle 1 lub 2 w zależności od tego, czy / bin / sh to bash, czy nie).

Tylko 64-bitowy system UNIX:

Wynik: ~ 10 ^ (40964096409640964096 * 40964096409640964096) / 88 ^ 3

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

C, 10 ^ 10 ^ 2485766 ≈ 10 ↑↑ 3,805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

Tworzymy tablicę 258048 liczb całkowitych bez znaku. Nie mogło być długo niepodpisanych, ponieważ to spowodowało, że program był zbyt długi. Są niepodpisane, ponieważ nie chcę używać niezdefiniowanego zachowania, ten kod jest poprawny C (poza brakiem powrotu z main ()) i będzie się kompilował i działał na każdym normalnym komputerze, ale będzie działał przez długi czas . Ten rozmiar jest największy, jaki możemy legalnie wyrazić bez użycia znaków innych niż ascii.

Pętlimy przez tablicę, zaczynając od ostatniego elementu. Drukujemy cyfry 2^32-1, zwiększamy element i upuszczamy pętlę, jeśli element nie jest zawinięty do 0. W ten sposób będziemy zapętlać (2^32 - 1)^254048 = 2^8257536czasy, drukując 10 cyfr za każdym razem.

Oto przykładowy kod, który pokazuje zasadę w bardziej ograniczonym zakresie danych:

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

Wynik wynosi około 10 ^ 10 ^ 2485766 podzielony przez milion, który wciąż wynosi około 10 ^ 10 ^ 2485766.

PowerShell (2,53e107976 / 72³ = 6,78e107970 ≈ 10 ↑↑ 1.701853371)

Uruchomienie zajmuje znacznie więcej niż 5 sekund.

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

Pobiera i konkatenuje długość bajtów każdego pliku na bieżącym dysku. Regex usuwa wszelkie znaki inne niż cyfry.

Python 3, wynik = ack (126 126) / 100 ^ 3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

Funkcja f to funkcja ackermann, do której wywołania mam wystarczająco dużo miejsca.

Edycja: poprzednio „else n + 1”, co było niezgodne z regułami wyzwań - uznanie dla Simply Beautiful Art.

JavaScript 98 znaków

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

generuje 2,718e + 239622337 ≈ 10 ↑↑ 2.9232195202

Za wynik nieco ponad 2,718e + 239622331 ≈ 10 ↑↑ 2.9232195197

co jest największym, jaki mogę zrobić bez awarii przeglądarki.

(console.log (a) pokaże pełne wyjście)

Nie uruchamiaj tych:

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

wyniesie 2,718 + e121333054704 ≈ 10 ↑↑ 3.0189898069 (alias 2,718 * 10 ^ (1,213 * 10 ^ 12), aby porównać do dłuższej odpowiedzi:

bardziej ekstremalna wersja, jeśli nie spowodowała awarii przeglądarki: (80 znaków)

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

co stworzyłoby liczbę mniej więcej tego samego rozmiaru co e * 10 ^ (10 ^ 19) ≈ 10 ↑↑ 3.106786869689

Edycja: zaktualizowane oryginalne rozwiązanie kodu wygenerowało tylko 2,718e + 464

Python 3: 98 znaków, ≈ 10 ↑↑ 256

Za pomocą funkcji argumentu zmiennej:

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

Skutecznie, E zmniejsza pierwszy argument, jednocześnie zwiększając pozostałe argumenty, z tym wyjątkiem, że zamiast wstawiania -1 w argumentach, upuszcza argument. Ponieważ każdy cykl zmniejsza pierwszy argument lub zmniejsza liczbę argumentów, gwarantuje to, że zostanie zakończony. Zastosowaną funkcją rosnącą jest int („% d% d”% (k, k)), co daje wynik między k ** 2 + 2 * k a 10 * k ** 2 + k. Mój kod używa symbolu * - ale nie jako mnożenia. Służy do pracy ze zmienną liczbą argumentów, które moim zdaniem powinny być zgodne z regułami, ponieważ wyraźnym celem reguł było ograniczenie określonych operacji, a nie samych symboli.

Kilka przykładów tego, jak duże E szybko dostaje się:

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

Tylko dwa pierwsze z nich można uruchomić na moim komputerze w rozsądnym czasie.

Następnie E wywoływane jest przez E(*range(ord('~')))- co oznacza:

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

Nie jestem do końca pewien, jak duży jest (próbowałem go przybliżyć bezskutecznie) - ale oczywiste jest, że jest ~ naprawdę ~ duży.

Na przykład, około dwunastu cykli, wynik jest około: (technicznie nieco więcej niż)

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

Oszacowanie wyniku:

Jeśli przybliżymy rosnący krok o lambda k: 10 * k**2, funkcję można opisać jako

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

Istotną rzeczą, którą tutaj robimy, jest zbudowanie dziesięcioosobowej wieży, więc ostateczny wynik można oszacować jako 10 ↑↑ 256.

Lepsze (choć częściowe) oszacowanie wyniku:

Wykorzystuje to to samo, 10 * k**2co inne oszacowania.

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

Zgodnie z poprzednim szacunkiem byłoby to:

E(a, b) = 10**(a**2/a) * b**(2*a)

Który jest znacznie mniejszy niż rzeczywista wartość, ponieważ używa a**2zamiast 2**adla 10 i używa a*2zamiast 2**adla b.

C (wynik ≈ 10 ^ 20 000 000 000 ≈ 10 ↑↑ 3,005558275)

• ~ 20 GB mocy wyjściowej
• 41 znaków (41 ^ 3 nic nie znaczy)

main(){for(;rand();printf("%d",rand()));}

Pomimo rand()wyniku jest deterministyczny, ponieważ nie ma funkcji początkowej.