Niektórzy z was mogą być zaznajomieni z BigNum Bakeoff , który skończył całkiem ciekawie. Cel można mniej więcej podsumować jako napisanie programu w C, którego wynik byłby największy, przy pewnych ograniczeniach i warunkach teoretycznych, np. Komputer, który mógłby uruchomić program.

W tym samym duchu stawiam podobne wyzwanie otwarte na wszystkie języki. Warunki są następujące:

• Maksymalnie 512 bajtów .

• Ostateczny wynik należy wydrukować na STDOUT. To jest twój wynik. Jeśli wydrukowanych zostanie wiele liczb całkowitych, zostaną one połączone.

• Dane wyjściowe muszą być liczbą całkowitą. (Uwaga: Infinity nie jest liczbą całkowitą .)

• Brak wbudowanych stałych większych niż 10, ale cyfry / cyfry są w porządku (np. Stała Avogadro (jako stała wbudowana) jest niepoprawna, ale 10000 nie.)

• Program musi zostać zakończony, gdy zostaną udostępnione wystarczające zasoby do uruchomienia.

• Wydruk musi być deterministyczny, jeśli zapewnia wystarczające zasoby do uruchomienia.

• Masz wystarczająco duże liczby całkowite lub duże, aby Twój program mógł działać. Na przykład, jeśli Twój program wymaga zastosowania podstawowych operacji na liczbach mniejszych niż 10 ^{1 000 000} , możesz założyć, że uruchomiony komputer może obsłużyć liczby co najmniej do 10 ^{1 000 000} . (Uwaga: Twój program może być również uruchomiony na komputerze, który obsługuje liczby do 10 ^{2 000 000} , więc po prostu wywołanie maksymalnej liczby całkowitej, którą komputer może obsłużyć, nie da wyników deterministycznych).

• Masz wystarczającą moc obliczeniową, aby Twój program mógł zakończyć działanie w mniej niż 5 sekund. (Więc nie martw się, jeśli Twój program działa przez godzinę na twoim komputerze i nie zakończy się w najbliższym czasie.)

• Brak zewnętrznych zasobów, więc nie myśl o zaimportowaniu tej funkcji Ackermann, chyba że jest ona wbudowana.

Wszystkie magiczne przedmioty są tymczasowo pożyczane od hojnego bóstwa.

Niezwykle duży z nieznanym limitem

• Steven H , Pyth f _{3 + B³F + ω²} (256 ²⁶ )

gdzie B³F jest porządkiem kościelno-kleeńskim z podstawową sekwencją

B³F[n] = B³F(n), the Busy Beaver BrainF*** variant
B³F[x] = x, ω ≤ x < B³F

Tabela liderów:

1. Po prostu piękna sztuka , Rubinowy f _{ψ 0 (X (Ω M + X (Ω M + 1 ^{Ω M + 1} ) )) + 29} (9 ^{9 9} )

2. Steven H , Pyth f _{ψ (Ω ^Ω ) + ω² + 183} (256 ^27! )

3. Leaky Nun , Python 3 f _{ε 0} (9 ^{9 9} )

4. fejfo , Python 3 f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999))

5. Steven H , Python 3 f _{ω ^ω + ω²} (9 ^{9 9 99} )

6. Simply Beautiful Art , Ruby f _{ω + 35} (9 ^{9 99} )

7. i .. , Python 2 , f ₃ (f ₃ (141))

Niektóre uwagi dodatkowe:

Jeśli nie możemy zweryfikować twojego wyniku, nie możemy umieścić go na tablicy wyników. Możesz więc spodziewać się trochę wyjaśnienia swojego programu.

Podobnie, jeśli nie rozumiesz, jak duża jest twoja liczba, wyjaśnij swój program, a my postaramy się to wypracować.

Jeśli używasz programu typu Loader , umieszczę cię w osobnej kategorii o nazwie „Bardzo duży z nieznanym limitem” , ponieważ liczba Loadera nie ma nietrywialnej górnej granicy pod względem szybko rosnącej hierarchii dla „ standardowe sekwencje podstawowe.

Liczby będą sortowane według szybko rosnącej hierarchii .

Dla tych, którzy chcieliby się nauczyć, jak używać szybko rosnącej hierarchii do przybliżania naprawdę dużych liczb, udostępniam właśnie serwer Discord . Istnieje również pokój rozmów: porządek .

Podobne wyzwania:

Największy numer do wydrukowania

Golf liczba większa niż DRZEWO (3)

Najkrótszy kończący program, którego rozmiar wyjściowy przekracza liczbę Grahama

Dla tych, którzy chcą zobaczyć proste programy, które generują szybko rosnącą hierarchię małych wartości, oto one:

Ruby: szybko rosnąca hierarchia

#f_0:
f=->n{n+=1}

#f_1:
f=->n{n.times{n+=1};n}

#f_2:
f=->n{n.times{n.times{n+=1}};n}

#f_3:
f=->n{n.times{n.times{n.times{n+=1}}};n}

#f_ω:
f=->n{eval("n.times{"*n+"n+=1"+"}"*n);n}

#f_(ω+1):
f=->n{n.times{eval("n.times{"*n+"n+=1"+"}"*n)};n}

#f_(ω+2):
f=->n{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}};n}

#f_(ω+3):
f=->n{n.times{n.times{n.times{eval("n.times{"*n+"n+=1"+"}"*n)}}};n}

#f_(ω∙2) = f_(ω+ω):
f=->n{eval("n.times{"*n+"eval(\"n.times{\"*n+\"n+=1\"+\"}\"*n)"+"}"*n);n}

itp.

Aby przejść od f_xdo f_(x+1), dodajemy jedną pętlę n.times{...}.

W przeciwnym razie przekątnie w stosunku do wszystkich poprzednich, np

f_ω(1) = f_1(1)
f_ω(2) = f_2(2)
f_ω(3) = f_3(3)

f_(ω+ω)(1) = f_(ω+1)(1)
f_(ω+ω)(2) = f_(ω+2)(2)
f_(ω+ω)(3) = f_(ω+3)(3)

itp.

Rubinowy, f _{ψ 0 (X (Ω M + X (Ω M + 1 ^{Ω M + 1} ) )) + 29} (9 ^{9 9} )

gdzie M jest pierwszą „porządkową” Mahlo, X jest funkcją chi (funkcja zwijania Mahlo), a ψ jest zwykłą funkcją zwijania.

f=->a,n,b=a,q=n{c,d,e=a;!c ?[q]:a==c ?a-1:e==0||e&&d==0?c:e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:n<1?9:!d ?[f[b,n-1],c]:c==0?n:[t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]};(x=9**9**9).times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{x.times{h=[];x.times{h=[h,h,h]};h=[[-1,1,[h]]];h=f[h,p x*=x]until h!=0}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

Wypróbuj online!

Podział kodu:

f=->a,n,b=a,q=n{          # Declare function
                c,d,e=a;          # If a is an integer, c=a and d,e=nil. If a is an array, a=[c,d,e].compact, and c,d,e will become nil if there aren't enough elements in a (e.g. a=[1] #=> c=1,d=e=nil).
                        !c ?[q]:          # If c is nil, return [q], else
                                a==c ?a-1:          # If a==c, return a-1, else
                                          e==0||e&&d==0?c:          # If e==0 or e is not nil and d==0, return c, else
                                                          e ?[[c,d,f[e,n,b,q]],f[d,n,b,q],c]:          # If e is not nil, return an array inside an array, else
                                                                                             n<1?9:          # If n<1, return 9, else
                                                                                                   !d ?[f[b,n-1],c]:          # If d is nil, return [f[b,n-1],c], else
                                                                                                                    c==0?n:          # If c==0, return n, else
                                                                                                                           [t=[f[c,n],d],n,c==-1?[]:d==0?n:[f[d,n,b,t]]]          # t=[f[c,n],d]. If c==-1, return [t,n,[]], else if d==0, return [t,n,n], else return [t,n,[f[d,n,b,t]]].
                                                                                                                                                                        };          # End of function
                                                                                                                                                                          (x=9**9**9)          # Declare x
                                                                                                                                                                                     x.times{...}          # Looped within 33 x.times{...} loops
                                                                                                                                                                                                 h=[];          # Declare h
                                                                                                                                                                                                      x.times{h=[h,h,h]};          # Nest h=[h,h,h] x times
                                                                                                                                                                                                                         h=f[h,p x*=x]          # Apply x*=x, print x, then h=f[h,x]
                                                                                                                                                                                                                                      until h==0          # Repeat previous line until h==0

Podział matematyki:

fzmniejsza ana podstawie n,b,q.

Podstawową ideą jest ekstremalnie zagnieżdżone a i zmniejszanie go wielokrotnie, aż zmniejszy się do a=0. Dla uproszczenia pozwól

g[0,n]=n
g[a,n]=g[f[a,n],n+1]

Na razie martwmy się tylko n.

Dla dowolnej liczby całkowitej kotrzymujemyf[k,n]=k-1 , więc możemy to zobaczyć

g[k,n]=n+k

Mamy wówczas, dla każdego d,f[[0,d],n]=n abyśmy mogli to zobaczyć

g[[0,d],n]
= g[f[[0,d],n],n+1]
= g[n,n+1]
= n+n+1

Mamy wówczas, dla każdego c,d,e,f[[c,0,e],n]=f[[c,d,0],n]=c . Na przykład,

g[[[0,d],0,e],n]
= g[f[[[0,d],0,e]],n+1]
= g[[0,d],n+1]
= (n+1)+(n+1)+1
= 2n+3

Mamy zatem, dla każdego c,d,etakiego, że nie mieści się w poprzednim przypadku,f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e] . Tu zaczyna się komplikować. Kilka przykładów:

g[[[0,d],1,1],n]
= g[f[[[0,d],1,1],n],n+1]
= g[[[0,d],1,0],0,[0,d]],n+1]
= g[f[[[0,d],1,0],0,[0,d]],n+1],n+2]
= g[[[0,d],1,0],n+2]
= g[f[[[0,d],1,0],n+2],n+3]
= g[[0,d],n+3]
= (n+3)+(n+3)+1
= 2n+7

#=> Generally g[[[0,d],1,k],n] = 2n+4k+3

g[[[0,d],2,1],n]
= g[f[[[0,d],2,1],n],n+1]
= g[[[[0,d],2,0],1,[0,d]],n+1]
= g[f[[[[0,d],2,0],1,[0,d]],n+1],n+2]
= g[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2]
= g[f[[[[[0,d],2,0],1,n+1],0,[[0,d],2,0]]],n+2],n+3]
= g[[[[0,d],2,0],1,n+1],n+3]
= ...
= g[[[0,d],2,0],3n+6]
= g[f[[[0,d],2,0],2n+6],3n+7]
= g[[0,d],3n+7]
= (3n+7)+(3n+7)+1
= 6n+15

Stamtąd szybko rośnie. Niektóre interesujące miejsca:

g[[[0,d],3,[0,d]],n] ≈ Ack(n,n), the Ackermann function
g[[[0,d],3,[[0,d],0,0]],63] ≈ Graham's number
g[[[0,d],5,[0,d]],n] ≈ G(2^^n), where 2^^n = n applications of 2^x, and G(x) is the length of the Goodstein sequence starting at x.

Ostatecznie wprowadzenie większej liczby argumentów ffunkcji oraz większej liczby przypadków dla tablicy pozwala nam przekroczyć większość nazwanych notacji obliczalnych. Niektóre szczególnie znane:

g[[[0],3,[0,d]],n] ≈ tree(n), the weak tree function
g[[[[0],3,[0,d]],2,[0,d]],n] ≈ TREE(n), the more well-known TREE function
g[[[[0,d]],5,[0,d]],n] >≈ SCG(n), sub-cubic graph numbers
g[[[0]],n] ≈ S(n), Chris Bird's S function

Pyth, f _{ψ (Ω ^Ω ) + ω ² +183} (~ 256 ^27! )

=QC`.pGL&=^QQ?+Ibt]0?htb?eb[Xb2yeby@b1hb)hbXb2yeb@,tb&bQ<b1=Y_1VQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQVQ.v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Qs["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q\YuyFYHpQ)

Wymaga niepustych danych wejściowych, ale ich wartość nie jest używana.

Objaśnienie (dla nowej wersji, która ma właściwie punktację ):

=QC`.pG                   Sets the value of the autofill variable to app. 256^27!  
                                  27! ~= the number of characters in the string
                                  containing all permutations of the alphabet. 
                                  We interpret that string as a base-256 number.
       L                  Define a function y(b,global Q):
        &=^QQ             Set Q to Q^Q and:
        ?+Ibt]0           If (?) the variable (b) is (I)nvariant on (+)adding itself
                             to the empty array (i.e. if it's an array itself):
               ?htb        If the second element of b is not 0:
                   ?eb         If the last element is not 0
                       [Xb2yeby@b1hG)   return [b with its last element replaced with y(b[-1]), y(b[1]), b[0]]
                     hb                 else return b[0]
                 Xb2yeb     else return b with its last element replaced with y(b[-1])
           @,tb&bQ<b1      If b isn't an array,return:
                               either b-1 if it's a standard ordinal (1 or more)
                               or Q if b is ω
                               or 0 if b is 0
 =Y_1                          Set the global variable Y to -1 (representing ω)
 VQ                        Q times, do (the rest of the explanation):
  VQVQ....VQ               Iterate from 0 to Q-1 183 times, each subiteration
                              reading the most recent value of Q when it starts:
  .v%%Fms["*s[.v"*\\^2d"\"%s"*\\^2d"\"")Q
                            Iterate from 0 to Q-1 Q times, each subiteration 
                               reading the most recent value of Q when it starts:                        
 s["=Y.v+*"*\\^2Q"\"*3]"*\\^2Q"\"Q
                             Y = [Y,Y,Y] Q times, stacking with previous iterations.
 uyFYHpQ)                    Run y_x(Y) for x incrementing until y_(x-1)(Y)=0

Bardzo trudno jest mi obliczyć wielkość tego, głównie dlatego, że jest późno i nie jestem zbyt dobrze zaznajomiony z szybko rozwijającymi się hierarchiami lub w jaki sposób spróbuję dowiedzieć się, ile razy Q przechodzi przez y()wyżymaczka. Chociaż teraz wiem więcej o porządkach, wciąż nie mam pojęcia, jak obliczyć wartość porządku reprezentowanego przez definicję rekurencyjną w moim programie. Przyłączę się do serwera Discord, ale pod pseudonimem wolałbym nie być powiązany z moim prawdziwym imieniem.

Niestety, ponieważ stosunkowo mało wiem o szybko rozwijających się hierarchiach, prawdopodobnie już przegrałem z odpowiedzią Ruby. Trudno mi powiedzieć. Być może pokonałem Rubinową odpowiedź, ale nie jestem w 100% pewien. ¯ \ _ (ツ) _ / ¯

Pyth, f _{3 + σ -1 + ω ²} (256 ²⁶ )

Gdzie σ _m [n] jest funkcją Busy Beaver Σ rzędu mwywoływanego n: σ _m [n] = Σ _m (n). Porządek -1polega na tym, że tutaj Busy Beaver nie jest wywoływany na prawdziwej maszynie Turinga, a raczej w przybliżeniu za pomocą skończonej taśmy owijającej Qelementy. Pozwala to rozwiązać problem zatrzymania w tych programach.

=QCGM.x-Hlhf!-/T4/T5.__<GH0M.x+Hlhf!-/T4/T5._>GHlGL=.<QC`m.uX@[XN2%h@N2l@N1XN2%t@N2l@N1XN1X@N1@N2%h@@N1@N2l@N1XN1X@N1@N2%t@@N1@N2l@N1XW!@@N1@N2N2nFKtPNXW@@N1@N2N2gFK)@hNeN3%heNlhNd)bLym*F[]d^UQQUQUld)^U6QJ"s*].v*\mQ"
.v+PPPP*JQ"+*\mQ\'

TL; DR polega na tym, że tworzy to wszystkie możliwe programy BrainF ** k o długości Q, uruchamia je w środowisku, w którym maksymalna wartość liczby całkowitej wynosi Q, a długość taśmy wynosi Q, i kompiluje wszystkie stany z tych operacji razem do dołącz (to jest 3+) do Q, powtarzając powyższe w skali f _{ω ²} .

Wciąż mam ~ połowę postaci, z którymi chciałbym pracować, jeśli chcę zrobić coś więcej, ale dopóki nie dowiemy się, gdzie to jest, zostawię to tak, jak jest.

python, f ₃ (f ₃ (141)), 512 bajtów

import math
def f(x):
    return math.factorial(x)  
x=9
for j in range(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(f(x))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))):
    x=f(x)
print x

To naprawdę nie jest poprawna odpowiedź, ale i tak chciałem ją opublikować. Szybkie podsumowanie:

import math # imports the factorial function
def f(x):
    return math.factorial(x) # shortens the factorial operation
x=9 # sets x to highest available number
for j in range(f(...f(x)...)): # repeats * A LOT *
    x=f(x) # does the factorial of x
print x # outputs the result

W każdym razie nie wiem, czy ta odpowiedź jest technicznie zgodna z prawem, ale pisanie było fajne. Edytuj wszelkie błędy znalezione w kodzie.

Ruby, prawdopodobnie ~ f _{ω + 35} (9 ^{9 99} )

G=->n,k{n<1?k:(f=->b,c,d{x=[]
c<G[b,d]?b-=1:(x<<=b;c-=G[b,d])while c>=d
x<<[c]}
x=f[n-1,k,b=1]
(b+=1;*u,v=x;x=v==[0]?u:v==[*v]?u<<[v[0]-1]:u+f[n-1,G[v,b]-1,b])while x[0]
b)};(n=9**9**99).times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n.times{n=G[n,n]}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}};p n

Wypróbuj online!

Przybliżone objaśnienie matematyczne:

Poniżej jest w przybliżeniu równy powyższemu programowi, ale jest uproszczony, aby był łatwiejszy do zrozumienia.

G(0,k) = k jest naszą podstawową funkcją.

Aby to ocenić G(n,k), bierzemy ki piszemy jako G(n-1,1) + ... + G(n-2,1) + ... + G(0,1).

Następnie zmień wszystkie G(x,1)„na G(x,2)” i odejmij 1od całego wyniku.

Przepisz go w powyższej formie, używając G(x,2), gdzie x<ni pozostaw resztę na końcu. Powtórz, zmień G(x,2)na G(x,3)itp.

Gdy wynik osiągnie -1, zwróć bazę ( bktóra byłaby w G(x,b).)

Przykłady:

G (1,1):

1: 1 = G(0,1)
2: G(0,2) - 1 = 1
3: 1 - 1 = 0
4: 0 - 1 = -1      <----- G(1,1) = 4

G (1,2):

1: 2 = G(0,1) + G(0,1)
2: G(0,2) + G(0,2) - 1 = G(0,2) + 1
3: G(0,3) + 1 - 1 = G(0,3)
4: G(0,4) - 1 = 3
5: 3 - 1 = 2
6: 2 - 1 = 1
7: 1 - 1 = 0
8: 0 - 1 = -1      <----- G(1,2) = 8

G (1,3):

1: 3 = G(0,1) + G(0,1) + G(0,1)
2: G(0,2) + G(0,2) + G(0,2) - 1 = G(0,2) + G(0,2) + 1
3: G(0,3) + G(0,3)
4: G(0,4) + 3
5: G(0,5) + 2
6: G(0,6) + 1
7: G(0,7)
8: 7
9: 6
10:5
11:4
12:3
13:2
14:1
15:0
16:-1      <----- G(1,3) = 16

G (2,5):

1: 5 = G(1,1) + G(0,1)
2: G(1,2) + 1
3: G(1,3)
4: G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + G(0,4) + 3
5: G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + G(0,5) + 2
6: G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + G(0,6) + 1
...
1024: -1      <----- G(2,5) = 1024

Robiąc matematykę, znalazłem to

G(1,n-1) = 2ⁿ
G(2,n+6) ~ 2^G(2,n),  large enough n.

Poza tym robi się trochę owłosiony.

Ogólnie mamy

G(n,k+G(n-1,1)) ~ G(n-1,G(n,k)), large enough n.

Python 3, f _{ω ^ω + ω * ω} (9 ^{9 9 99} )

from functools import*
h=lambda a,x,b:h(h(a,x,b-1),x-1,a)if x*b else a+b
def f(*x):
    if(any(x[:2]):return reduce(lambda y,z:h(z,y,f(x[0],x[1]-1,*x[2:])),x[::-1])if x[0]*x[1]else(f(x[0]-1,f(x[0]-1,x[0],*x[2:]))if x[0]>x[1]else(f(x[1]-1,f(*([x[1]-1]*2+x[2:])),*x[2:])))
    for a,k in enumerate(x):if k:return f(*[f(*[k]*a,k-1,*x[a+1:])]*a,k-1,*x[a+1:])
    return 0
x,s,g,e,r,z=9**9**9**99,"f(*[%s]*%s)",lambda a,b:a%((b,)*a.count("%")),"x*=eval(\"%s\");","x","x=g(e,g(reduce(g,[s]*x,s),r));"
print(exec(z*x)or eval(r))

Wkrótce otrzymam wyjaśnienie.

Python 3 , ~ f _{ε 0} (9 ^{9 9} )

N=9**9**9
def f(a,n):
 if a[0]==[]:return a[1:]
 if a[0][0]==[]:return[a[0][1:]]*n+a[1:]
 return [f(a[0],n)]+a[1:]
a=eval("["*N+"]"*N)
n=2
while a:a=f(a,n);n+=1
print(n)

Wypróbuj online!

Python 3, 323 bajty, g ^9e9 (9)

exec("""a=`x:9**x
n=`a,f:`x:a and n(a-1,f)(f(x))or x
c=`n:`l:l[~n](l)
e=`x:n(x,c(0))([x,`l:[a(l[0]),n(*l)],c(0),`l:[a(l[0]),l[2](l[:2])[1]]+map(`i:l[1]((l[0],i))[1],l[2:])]+list(map(c,range(a(x),1,-1))))[1]
f=`l:[l[1](l[0]),e(l[1](l[0]))(l)[1]]
g=`x:e(x)((x,f))[1]((x,a))[1](x)
print(n(9e9,g)(9))""".replace('`','lambda '))

Wypróbuj online!

Wyjaśnienie

Python 3 jest naprawdę rekurencyjnym językiem, co oznacza, że ​​nie tylko samo wywołanie funkcji może pełnić inne funkcje jako funkcje wejściowe lub wyjściowe. Używanie funkcji do ulepszania się jest tym, na czym opiera się mój program.

f = lambda x, a: [a (x), e (x) ((x, a)) [1]]

Definicja

a(x)=9^x
b(x,f)=a(x), f^x
c(n)(*l)=l[~n](l)
c(0)=c0 <=> c0(…,f)=f(…,f)
d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l
e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1] 
f(x,a)=a(x),e(a(x))(x,a)[1](x)
g(x)=e(x)(x,f)[1](x,a)[1](x)
myNumber=g^9e9(9)

Definicja wyjaśniona

a(x)=9^x a jest funkcją podstawową, wybrałem tę funkcję, ponieważ x> 0 => a (x)> x`, która pozwala uniknąć punktów stałych.

b(x,f)=a(x), f^xb jest ogólną funkcją ulepszającą, przyjmuje dowolną funkcję i generuje lepszą wersję. b można nawet zastosować do siebie:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

ale aby w pełni wykorzystać moc bulepszania b, musisz wziąć wynik b i użyć go jako nowego b, to właśnie robi c0:

c0(…,f)=f(…,f)
c0(x,b^x)=b^x(x,b^x)[1]>b^(9↑↑x)

bardziej ogólna funkcja c (n) przyjmuje n ostatni argument (zaczynając od 0) tak c(1)(…,f,a)=f(…,f,a)i c(2)(…,f,a,b)=f(…,f,a,b). *loznacza, że ​​l jest tablicą i l[~n]przyjmuje n ostatni argument

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in ld używa c0 do aktualizacji b i b do aktualizacji wszystkich innych funkcji wejściowych (których może być dowolna ilość z powodu listy)
d(x,b,c,d)>9^x,b^x,c^x,d^xid²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

ale d staje się jeszcze lepszy, jeśli połączysz go z c:
c0²(x,b,c0,d)=d^x(9^x,b^x,c0^x,d^x)=… c0(x,b,c0,d,c1)=c1(x,b,c0,d,c1)=d(x,b,c0,d,c1)=9^x,b^x,c0^x,d^x,c1^x c0²(x,b,c0,d,c1)=c0(9^x,b^x,c0^x,d^x,c1^x)=c1^x(9^x,b^x,c0^x,d^x,c1^x)=…

im więcej c (x) dodasz na końcu, tym bardziej staje się ono potężne. Pierwsze c0 zawsze pozostaje d: c0(x,b,c0,d,c4,c3,c2,c1)=c1(…)=c2(…)=c3(…)=c4(…)=d(x,b,c0,d,cX,cX-1,…,c3,c2,c1)=…
Ale drugie pozostawia wersje iterowane:

c0²(x+1,b,c0,d,c4,c3,c2,c1)
=c0(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)
=c1^x(c2^x(c3^x(c4^x(d^x(9^x+1,b^x+1,c0^x+1,d^x+1,c4^x+1,c3^x+1,c2^x+1,c1^x+1)))))

Kiedy d^xzostanie ostatecznie obliczony, następnym razem c4zajmie dużo więcej iterowanej wersji d. Kiedy c4^xzostanie ostatecznie obliczone c3, zajmie dużo bardziej iterowaną wersję c4…
To tworzy naprawdę potężną wersję iteracji, ponieważ d:

1. Poprawia bużyciec0
2. Poprawia c0użycieb
3. Ulepsza wszystkie warstwy zagnieżdżania za pomocą b Ulepszenia same się poprawiają, co oznacza, że ​​d staje się silniejszy, gdy jest iterowany więcej.

Tworzenie tego długiego łańcucha c jest tym, co e(x)=c0^x(x,b,c0,d,c(a(x)),c(a(x)-1),c(a(x)-2),…,c(3),c(2),c(1))[1]robi.
Wykorzystuje się c0^xdo ominięcia, c0które po prostu dałoby d.
Te [1]środki, które będą ostatecznie powrócić Drugie wyjście d^…. Tak b^….

W tym momencie nie mogłem wymyślić nic wspólnego z e (x), aby znacznie zwiększyć jego moc wyjściową, z wyjątkiem zwiększenia nakładów.

f(x,a)=a(x),e(a(x))(x,a)[1](x)Używa więc b^…wygenerowanego przez, e(x)aby wyprowadzić lepszą funkcję podstawową i wykorzystuje tę funkcję podstawową do wywołania e(x)z większym wejściem.

g(x)=e(x)(x,f)[1](x,a)[1](x)używa finału e(x)do zagnieżdżenia fi tworzy naprawdę potężną funkcję.

Przybliżenie Fgh

Będę potrzebować pomocy w przybliżeniu tej liczby za pomocą dowolnego fgh.

Stara wersja : f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999)), Wypróbuj online! Historia zmian wyjaśnienia

Rubinowy, f _{ε 0 2} (5), 271 bajtów

m=->n{x="";(0..n).map{|k|x+="->f#{k}{"};x+="->k{"+"y=#{n<1??k:"f1"};k.times{y=f0[y]};y";(2..n).map{|l|x+="[f#{l}]"};eval x+(n<1?"":"[k]")+"}"*(n+2)}
g=->z{t="m[#{z}]";(0...z).map{|j|t+="[m[#{z-j-1}]]"};eval t+"[->n{n+n}][#{z}]"}
p m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]

Wypróbuj online!

Jest to oparte na mapie m (n) .

Wyjaśnienie:

m[0][f0][k] = f0[f0[...f0[k]...]]z kiteracjami f0.

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]z kiteracjami f0.

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]z kiteracjami f0.

Generalnie, m[n]przyjmuje się n+2argumentów iteracje pierwszego argumentu f0, krazy na drugim argumencie, a następnie stosuje się wynik funkcji na trzecim argumencie (jeśli istnieje), a następnie stosuje się wynik funkcji na czwartego argumentu (jeśli istnieje), itp.

Przykłady

m[0][n↦n+1][3] = (((3+1)+1)+1 = 6

Na ogół m[0][n↦n+1] = n↦2n.

m[0][m[0][n↦n+1]][3] = m[0][n↦2n][3] = 2(2(2(3))) = 24

Na ogół m[0][m[0][n↦n+1]] = n↦n*2^n.

m[1][m[0]][3]
= m[0][m[0][m[0][n↦n+1]]][3]
= m[0][m[0][n↦2n]][3]
= m[0][n↦n*2^n][3]
= (n↦n*2^n)[(n↦n*2^n)[n↦n*2^n(3)]]
= (n↦n*2^n)[(n↦n*2^n)[24]]
= (n↦n*2^n)[402653184]
= 402653184*2^402653184

Ogólnie m[1][m[0]][n↦n+1] = f_ωw szybko rosnącej hierarchii.

g[z] = m[z][m[z-1]][m[z-2]]...[m[1]][m[0]][n↦2n][z]

i końcowy wynik jest

m[5][m[4]][m[3]][m[2]][m[1]][m[0]][g][6]