Beberapa dari Anda mungkin akrab dengan BigNum Bakeoff , yang berakhir dengan cukup menarik. Tujuannya kurang lebih dapat diringkas sebagai menulis program C yang outputnya akan menjadi yang terbesar, di bawah beberapa kendala dan kondisi teoritis misalnya komputer yang dapat menjalankan program.

Dengan semangat yang sama, saya mengajukan tantangan serupa yang terbuka untuk semua bahasa. Syaratnya adalah:

• Maksimum 512 byte .

• Hasil akhir harus dicetak ke STDOUT. Ini skor kamu. Jika beberapa bilangan bulat dicetak, mereka akan digabungkan.

• Output harus berupa bilangan bulat. (Catatan: Infinity bukan bilangan bulat .)

• Tidak ada konstanta bawaan yang lebih besar dari 10, tetapi angka / digit baik-baik saja (mis. Konstanta Avogadro (sebagai konstanta bawaan) tidak valid, tetapi 10.000 tidak.)

• Program harus diakhiri ketika sumber daya yang disediakan cukup untuk dijalankan.

• Hasil cetak harus deterministik ketika disediakan sumber daya yang cukup untuk dijalankan.

• Anda diberikan bilangan bulat atau bigint yang cukup besar untuk dijalankan oleh program Anda. Misalnya, jika program Anda mengharuskan penerapan operasi dasar ke angka yang lebih kecil dari 10 ^1.000.000 , maka Anda dapat menganggap komputer yang menjalankan ini dapat menangani angka setidaknya hingga 10 ^1.000.000 . (Catatan: Program Anda juga dapat dijalankan pada komputer yang menangani angka hingga 10 ^2.000.000 , jadi hanya memanggil bilangan bulat maksimum yang dapat ditangani komputer tidak akan menghasilkan hasil yang deterministik.)

• Anda diberikan daya komputasi yang cukup untuk program Anda untuk menyelesaikan eksekusi dalam waktu kurang dari 5 detik. (Jadi jangan khawatir jika program Anda telah berjalan selama satu jam di komputer Anda dan tidak akan selesai dalam waktu dekat.)

• Tidak ada sumber daya eksternal, jadi jangan berpikir untuk mengimpor fungsi Ackermann kecuali itu built-in.

Semua benda ajaib dipinjam sementara dari dewa yang murah hati.

Sangat besar dengan batas yang tidak diketahui

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

di mana B³F adalah ordinal Gereja-Kleene dengan urutan mendasar

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

Papan peringkat:

1. Seni Cukup Cantik , Ruby 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))

Beberapa catatan:

Jika kami tidak dapat memverifikasi skor Anda, kami tidak dapat meletakkannya di papan peringkat. Jadi, Anda mungkin ingin sedikit menjelaskan program Anda.

Demikian juga, jika Anda tidak mengerti seberapa besar angka Anda, jelaskan program Anda dan kami akan mencoba menyelesaikannya.

Jika Anda menggunakan jenis program Loader , saya akan menempatkan Anda dalam kategori terpisah yang disebut "Sangat besar dengan batas tidak diketahui" , karena nomor Loader tidak memiliki batas atas non-sepele dalam hal hierarki yang tumbuh cepat untuk ' urutan dasar standar '.

Angka akan diberi peringkat melalui hierarki yang tumbuh cepat .

Bagi mereka yang ingin belajar bagaimana menggunakan hierarki yang tumbuh cepat untuk memperkirakan jumlah yang sangat besar, saya hosting server Discord hanya untuk itu. Ada juga ruang obrolan: Ordinality .

Tantangan serupa:

Nomor Terbesar yang Dapat Dicetak

Golf angka lebih besar dari TREE (3)

Program terminasi terpendek yang ukuran outputnya melebihi angka Graham

Bagi mereka yang ingin melihat beberapa program sederhana yang menghasilkan hierarki yang tumbuh cepat untuk nilai-nilai kecil, inilah mereka:

Ruby: hierarki yang tumbuh cepat

#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}

dll.

Untuk beralih dari f_xke f_(x+1), kami menambahkan satu loop dari n.times{...}.

Kalau tidak, kita mendiagonalisasi terhadap semua contoh sebelumnya

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)

dll.

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

di mana M adalah 'ordinal' Mahlo pertama, X adalah fungsi chi (fungsi Mahlo runtuh), dan ψ adalah fungsi runtuh ordinal.

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}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

Cobalah online!

Rincian Kode:

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

Rincian Matematika:

fmengurangi aberdasarkan n,b,q.

Ide dasarnya adalah membuat sarang yang sangat bersarang adan menguranginya berulang kali hingga berkurang menjadi a=0. Untuk kesederhanaan, biarkan

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

Untuk saat ini, mari kita khawatirkan saja n.

Untuk bilangan bulat apa pun k, kami dapat f[k,n]=k-1, sehingga kami dapat melihatnya

g[k,n]=n+k

Kami kemudian memiliki, untuk setiap d, f[[0,d],n]=nsehingga kita dapat melihat bahwa

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

Kami kemudian memiliki, untuk setiap c,d,e, f[[c,0,e],n]=f[[c,d,0],n]=c. Sebagai contoh,

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

Kami kemudian memiliki, untuk apa pun c,d,eyang tidak termasuk dalam kasus sebelumnya f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e],. Di sinilah mulai rumit. Beberapa contoh:

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

Dengan cepat landai dari sana. Beberapa tempat menarik:

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.

Akhirnya memperkenalkan lebih banyak argumen ffungsi serta lebih banyak kasus untuk array memungkinkan kita untuk melampaui sebagian besar notasi yang dapat dihitung. Beberapa yang sangat dikenal:

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)

Membutuhkan input yang tidak kosong, tetapi nilainya tidak digunakan.

Penjelasan (untuk versi baru dan benar-benar skor ):

=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

Sangat sulit bagi saya untuk menghitung ukuran ini, terutama karena ini sudah sore dan saya tidak terlalu akrab dengan hierarki yang tumbuh cepat atau bagaimana saya akan mencoba mencari tahu berapa kali Q melewati y()alat pemeras. Sementara saya sekarang tahu lebih banyak tentang tata cara, saya masih tidak tahu bagaimana menghitung nilai tata cara yang diwakili oleh definisi rekursif dalam program saya. Saya akan bergabung dengan server Discord, tapi itu dengan nama samaran saya lebih suka tidak dihubungkan dengan nama asli saya.

Sayangnya, karena saya tahu sedikit tentang kata hierarki yang tumbuh cepat, saya mungkin sudah kehilangan jawaban Ruby. Sulit bagi saya untuk mengatakannya. Saya mungkin telah mengalahkan jawaban Ruby, tetapi saya tidak 100% yakin. ¯ \ _ (ツ) _ / ¯

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

Di mana σ _m [n] adalah fungsi Sibuk Berang Σ dari urutan yang mdipanggil n: σ _m [n] = Σ _m (n). Perintahnya -1adalah untuk menunjukkan bahwa Berang-berang Sibuk di sini tidak dipanggil pada Mesin Turing yang sebenarnya, melainkan perkiraan dengan pita pembungkus Qelemen yang terbatas . Ini memungkinkan masalah penghentian untuk dipecahkan untuk program-program ini.

=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 adalah bahwa ini menciptakan semua kemungkinan program BrainF ** k panjang Q, menjalankannya dalam lingkungan di mana nilai maksimum bilangan bulat adalah Q dan panjang pita adalah Q, dan mengkompilasi semua status dari operasi ini bersama-sama untuk tambahkan (itu adalah 3+) ke Q, ulangi di atas pada skala f _{ω ²} .

Saya masih memiliki ~ setengah karakter untuk dikerjakan jika saya ingin melakukan sesuatu yang lebih, tetapi sampai kita mengetahui di mana ini saya akan membiarkannya apa adanya.

python, f ₃ (f ₃ (141)), 512 byte

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

Ini sebenarnya bukan jawaban yang valid, tetapi saya tetap ingin mempostingnya. Ikhtisar cepat:

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

Lagi pula, saya tidak tahu apakah jawaban ini secara teknis sah, tetapi menyenangkan untuk menulis. Jangan ragu untuk mengedit kesalahan yang Anda temukan dalam kode.

Ruby, mungkin ~ 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

Cobalah online!

Perkiraan Penjelasan Matematika:

Di bawah ini kira-kira sama dengan program di atas, tetapi disederhanakan sehingga lebih mudah dimengerti.

G(0,k) = k adalah fungsi dasar kami.

Untuk mengevaluasi G(n,k), kami mengambil kdan menuliskannya sebagaiG(n-1,1) + ... + G(n-2,1) + ... + G(0,1) .

Kemudian ubah semua G(x,1)menjadi G(x,2)dan kurangi1 dari seluruh hasil.

Tulis ulang dalam bentuk di atas menggunakan G(x,2), di mana x<n, dan biarkan sisanya di akhir. Ulangi, ubah G(x,2)ke G(x,3), dll.

Ketika hasilnya mencapai -1, kembalikan pangkalan ( byang akan masuk G(x,b).)

Contoh:

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

Melakukan matematika, saya menemukan itu

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

Dan di luar itu cenderung menjadi sedikit berbulu.

Secara umum, kita punya

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))

Saya akan segera mendapatkan penjelasan.

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)

Cobalah online!

Python 3, 323 byte, 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 '))

Cobalah online!

Penjelasan

Python 3 adalah bahasa yang benar-benar rekursif, ini berarti bahwa tidak hanya fungsi dapat memanggil dirinya sendiri, suatu fungsi juga dapat mengambil fungsi lain sebagai fungsi input atau output. Menggunakan fungsi untuk membuat diri mereka lebih baik adalah dasar dari program saya.

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

Definisi

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)

Definisi dijelaskan

a(x)=9^x a adalah fungsi dasar, saya memilih fungsi ini karena x> 0 => a (x)> x` yang menghindari titik tetap.

b(x,f)=a(x), f^xb adalah fungsi peningkatan umum, dibutuhkan dalam fungsi apa pun dan mengeluarkan versi yang lebih baik. b bahkan dapat diterapkan pada dirinya sendiri:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

tetapi untuk sepenuhnya menggunakan kekuatan buntuk meningkatkan bAnda perlu mengambil output dari b dan menggunakannya sebagai b baru, inilah yang dilakukan c0:

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

fungsi c (n) yang lebih umum mengambil n argumen terakhir (mulai dari 0) jadi c(1)(…,f,a)=f(…,f,a)dan c(2)(…,f,a,b)=f(…,f,a,b). *lberarti l adalah array dan l[~n]mengambil argumen terakhir

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l d menggunakan c0 untuk memutakhirkan b dan b untuk memutakhirkan semua fungsi input lainnya (yang jumlahnya bisa berapa saja karena daftar)
d(x,b,c,d)>9^x,b^x,c^x,d^x dand²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

tetapi d menjadi lebih baik jika Anda menggabungkannya dengan 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)=…

semakin banyak c (x) yang Anda tambahkan di akhir semakin kuat jadinya. C0 pertama selalu tetap 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)=…
Tetapi yang kedua meninggalkan versi berulang di belakang:

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)))))

Ketika d^xakhirnya dihitung c4akan mengambil versi yang lebih banyak diulang dari dwaktu berikutnya. Ketika c4^xakhirnya dihitung c3akan mengambil versi iterasi yang lebih banyak c4, ...
Ini menciptakan versi iterasi yang sangat kuat karena d:

1. Meningkatkan bpenggunaanc0
2. Meningkatkan c0penggunaanb
3. Memperbaiki semua lapisan sarang menggunakan b Semakin meningkatkan diri, ini berarti d menjadi lebih kuat ketika iterasi lebih banyak.

Menciptakan rantai panjang c ini adalah apa yang 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]dilakukannya.
Ini digunakan c0^xuntuk memotong yang c0hanya akan memberi d.
The [1]berarti bahwa pada akhirnya akan kembali output kedua d^…. Begitub^… .

Pada titik ini saya tidak bisa memikirkan apa pun yang berkaitan dengan e (x) untuk secara signifikan meningkatkan outputnya kecuali meningkatkan input.

Jadi f(x,a)=a(x),e(a(x))(x,a)[1](x)gunakan yang b^…dihasilkan oleh e(x)untuk menghasilkan fungsi basis yang lebih baik dan menggunakan fungsi basis itu untuk memanggil e(x)dengan input yang lebih besar.

g(x)=e(x)(x,f)[1](x,a)[1](x)menggunakan final e(x)ke sarangf dan menghasilkan fungsi yang sangat kuat.

Perkiraan Fgh

Saya perlu bantuan perkiraan angka ini dengan segala macam fgh.

Versi lama : f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999)), Coba online! Revisi riwayat penjelasan

Ruby, f _{ε 0 2} (5), 271 byte

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]

Cobalah online!

Ini didasarkan pada peta m (n) .

Penjelasan:

m[0][f0][k] = f0[f0[...f0[k]...]]dengan kiterasi dari f0.

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]dengan kiterasi dari f0.

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]dengan kiterasi dari f0.

Secara umum, m[n]mengambil n+2argumen, iterates argumen pertama f0,k kali ke argumen kedua, dan kemudian menerapkan fungsi yang dihasilkan ke argumen ketiga (jika ada), lalu menerapkan fungsi yang dihasilkan ke argumen keempat (jika ada), dll.

Contohnya

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

Secara umum 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

Secara umum 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

Secara umum, m[1][m[0]][n↦n+1] = f_ωdalam hierarki yang tumbuh cepat.

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

dan hasil akhirnya adalah

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