Bazılarınız oldukça ilginç olan BigNum Bakeoff'u biliyor olabilirsiniz . Amaç, az çok, çıktıları en büyük olan bir C programı yazmak, örneğin programı çalıştırabilecek bir bilgisayar gibi bazı kısıtlamalar ve teorik koşullar altında özetlemek olarak özetlenebilir.

Aynı ruhla, tüm dillere benzer bir meydan okuma getiriyorum. Koşullar:

• Maksimum 512 bayt .

• Nihai sonuç STDOUT'a yazdırılmalıdır. Bu senin puanın. Birden fazla tam sayı yazdırılırsa, bunlar birleştirilecektir.

• Çıktı bir tamsayı olmalıdır. (Not: Sonsuzluk bir tamsayı değildir .)

• 10'dan büyük yerleşik sabit yok, ancak sayılar / basamaklar iyi (örn. Avogadro sabiti (yerleşik bir sabit olarak) geçersiz, ancak 10000 değil).

• Çalıştırılması için yeterli kaynak sağlandığında program sonlandırılmalıdır .

• Çalıştırmak için yeterli kaynak sağlandığında, yazdırılan çıktı belirleyici olmalıdır .

• Programınızın çalışması için size yeterince büyük tamsayılar veya büyük noktalar sağlanır. Örneğin, programınız 10 ^{1.000.000'dan} küçük sayılara temel işlemler uygulanmasını gerektiriyorsa , bunu çalıştıran bilgisayarın en az 10 ^1.000.000'a kadar sayıları işleyebileceğini varsayabilirsiniz . (Not: Programınız ayrıca ^10.000.000'a kadar sayıları işleyen bir bilgisayarda da çalıştırılabilir , bu nedenle bilgisayarın işleyebileceği maksimum tamsayıyı çağırmak belirleyici sonuçlar doğurmaz.)

• Programınızın 5 saniyeden kısa sürede tamamlanması için yeterli bilgi işlem gücü sağlanmıştır. (Bu nedenle, programınız bilgisayarınızda bir saattir çalışıyorsa ve yakında hiçbir zaman bitmeyecekse endişelenmeyin.)

• Harici kaynak yok, bu yüzden yerleşik olmadığı sürece bu Ackermann işlevini içe aktarmayı düşünmeyin.

Tüm büyülü eşyalar geçici olarak cömert bir tanrıdan ödünç alınıyor.

Sınırı bilinmeyen aşırı büyük

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

burada B³F, kilise-Kleene ordinalidir.

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

Liderler Sıralaması:

1. Sade Güzel Sanatlar , Yakut f _{ψ 0 (X (Ω M + X (Ω M + 1 ^{Ω M + 1} ) )) + 29} (9 ^{9 9} )

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

3. Sızdıran Rahibe , 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. Sade Güzel Sanatlar , Yakut f _{ω + 35} (9 ^{9 99} )

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

Bazı yan notlar:

Puanınızı doğrulayamazsak, skor tablosuna koyamayız. Yani programınızı biraz açıklamayı bekleyebilirsiniz.

Aynı şekilde, numaranızın ne kadar büyük olduğunu anlamadıysanız, programınızı açıklayın, biz de bunu çözmeye çalışacağız.

Eğer bir kullanırsanız Loader numaralı programı türünü aradım ayrı kategoride sizi yerleştiririz "bilinmeyen limitli Çok büyük" Loader numaralı üst 'için hızla büyüyen hiyerarşi açısından bağlı önemsiz olmayan bir olmadığı için, standart 'temel diziler.

Sayılar hızla büyüyen hiyerarşi ile sıralanacaktır .

Hızlı büyüyen hiyerarşiyi gerçekten çok büyük sayılara yaklaşık olarak nasıl kullanacağını öğrenmek isteyenler için, sadece bunun için bir Discord sunucusu barındırıyorum . Bir sohbet odası da var: Ordinality .

Benzer zorluklar:

Yazdırılabilir En Büyük Sayı

Golf AĞAÇTAN büyük bir sayı (3)

Çıktı boyutu Graham'ın sayısını aşan en kısa sonlandırma programı

Küçük değerler için hızla büyüyen hiyerarşiyi çıkaran bazı basit programları görmek isteyenler için işte bunlar:

Ruby: hızlı büyüyen hiyerarşi

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

vb.

- arasında gitmek f_xiçin f_(x+1),n.times{...} .

Aksi takdirde, önceki tüm öğelere çaprazlama yaparız, ör.

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)

vb.

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

burada M , ilk Mahlo 'ordinal', X , chi fonksiyonudur (Mahlo çöken fonksiyon) ve ψ , ordinal çöken fonksiyondur.

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

Çevrimiçi deneyin!

Kod Dağılımı:

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

Matematik Dağılımı:

fazaltır agören,b,q .

Temel fikir son derece iç içe geçmiş olmak ave düşene kadar tekrar tekrar azaltmaktır a=0. Basitlik için

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

Şimdilik sadece endişelenelim n .

Herhangi bir tamsayı için kanlıyoruz f[k,n]=k-1, böylece

g[k,n]=n+k

Daha sonra, herhangi biri için d, f[[0,d],n]=nbunu görebiliyoruz.

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

Sonra herhangi biri için, var c,d,e, f[[c,0,e],n]=f[[c,d,0],n]=c. Örneğin,

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

Daha sonra c,d,e, bir önceki duruma düşmeyecek herhangi bir şey için f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e]. Burası karmaşıklaşmaya başlıyor. Birkaç örnek:

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

Oradan hızla yükseliyor. Bazı ilgi çekici noktalar:

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.

Sonunda, fişlevin daha fazla argümanının yanı sıra dizi için daha fazla vaka sunmak, en çok adlandırılan hesaplanabilir gösterimleri aşmamızı sağlar. Özellikle bilinen bazıları:

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)

Boş olmayan herhangi bir giriş gerektirir, ancak değeri kullanılmaz.

Açıklama ( yeni ve gerçekten makul skorlu sürüm için):

=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

Bunun büyüklüğünü hesaplamak benim için çok zor, çünkü çoğunlukla günün geç saatlerinde ve hızlı büyüyen hiyerarşilere ya da Q'nun kaç kez geçtiğini anlamaya çalıştığımı bile bilmiyorum. y()merdane. Artık ordinaller hakkında daha fazla bilgi sahibi olsam da, programımdaki özyinelemeli tanımla temsil edilen ordinalin değerini nasıl hesaplayacağımı hala bilmiyorum. Discord sunucusuna katılırdım, ama gerçek adımla ilişkilendirilmemeyi tercih ettiğim bir takma ad altında.

Ne yazık ki, söz konusu hızlı büyüyen hiyerarşiler hakkında nispeten az şey bildiğim için, Ruby cevabını zaten kaybetmişimdir. Söylemesi zor. Ruby cevabını yenmiş olabilirim, ama% 100 emin değilim. ¯ \ _ (ツ) _ / ¯

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

Σ _m [n], Meşgul Kunduz fonksiyonu Σ olarak madlandırılan sırayla n: σ _m [n] = Σ _m (n). Emir -1, burada Meşgul Kunduzun gerçek bir Turing Makinesi üzerinde çağrılmadığını, bunun yerine sonlu bir sargı bandıyla yaklaşık birQ . Bu, durma sorununun bu programlar için çözülebilmesini sağlar.

=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, bunun Q uzunluktaki tüm olası BrainF ** k programlarını oluşturması, bunları bir tamsayının maksimum değerinin Q olduğu ve bant uzunluğunun Q olduğu bir ortamda çalıştırması ve bu işlemlerden tüm durumları bir araya getirmesidir. 3+yukarıdakileri f _{ω ²} ölçeğinde yineleyerek Q'ya (bu ) ekleyin .

Daha fazla bir şey yapmak istersem hala çalışacak karakterlerin yarısı var, ama bunun nerede olduğunu bulana kadar onu olduğu gibi bırakacağım.

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

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

Bu gerçekten geçerli bir cevap değil, ama yine de göndermek istedim. Hızlı bir özet:

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

Her neyse, bu cevabın teknik olarak yasal olup olmadığını bilmiyorum, ama yazmak eğlenceliydi. Kodda bulduğunuz hataları düzenlemekten çekinmeyin.

Yakut, muhtemelen ~ 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

Çevrimiçi deneyin!

Yaklaşık Matematik Açıklaması:

Aşağıdakiler yukarıdaki programa yaklaşık olarak eşittir, ancak anlaşılması daha kolay olacak şekilde basitleştirilmiştir.

G(0,k) = k bizim temel fonksiyonumuzdur.

Değerlendirmek için G(n,k)alıyor kve yazıyoruz G(n-1,1) + ... + G(n-2,1) + ... + G(0,1).

Daha sonra tüm G(x,1)'leri' olarak değiştirin ve tüm sonuçtan G(x,2)çıkarın 1.

Yukarıdaki formu G(x,2)nerede x<n, nerede kullanarak yeniden yazın ve kalanını sonunda bırakın. Değişen, Tekrar G(x,2)etmekG(x,3) vs.

Sonuç ulaştığında -1, üssü geri getirin ( biçinde olacaktır G(x,b).)

Örnekler:

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

Biraz matematik yaparak bunu buldum

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

Ve bunun ötesinde biraz kıllı olma eğilimindedir.

Genel olarak,

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

Yakında bir açıklama yapacağım.

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)

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

açıklama

Python 3 gerçekten özyinelemeli bir dildir, bu sadece bir fonksiyon çağrısının kendisinin değil, bir fonksiyonun diğer fonksiyonları giriş veya çıkış fonksiyonları olarak da alabileceği anlamına gelir. Kendilerini daha iyi hale getirmek için fonksiyonları kullanmak, programımın temelini oluşturuyor.

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

Tanım

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)

Tanım açıklandı

a(x)=9^x a temel işlevdir, bu işlevi seçtim çünkü sabit noktaları önleyen x> 0 => a (x)> x`.

b(x,f)=a(x), f^xb genel iyileştirme işlevidir, herhangi bir işlevi alır ve daha iyi bir sürümünü çıkarır. b bile kendisine uygulanabilir:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

ancak tam olarak gücünü bartırmak biçin, b'nin çıktısını almanız ve yeni b olarak kullanmanız gerekir, c0'ın yaptığı şey budur:

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

Daha genel c (n) fonksiyonu, n geçen argüman (0 dan başlayarak) çok alır c(1)(…,f,a)=f(…,f,a)ve c(2)(…,f,a,b)=f(…,f,a,b).*ll bir dizi demektir ve l[~n]son argümanı alır

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l d, yükseltmek için c0'ı kullanır ve diğer giriş işlevlerinin tümünü yükseltmek için b ve b'yi kullanır (bunların listesi nedeniyle herhangi bir miktar olabilir)
d(x,b,c,d)>9^x,b^x,c^x,d^x ved²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

ancak c ile birleştirirseniz d daha da iyi olur:
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)=…

sonunda ne kadar c (x) eklerseniz o kadar güçlü olur. İlk c0 daima d olarak kalır:c0(x,b,c0,d,c4,c3,c2,c1)=c1(…)=c2(…)=c3(…)=c4(…)=d(x,b,c0,d,cX,cX-1,…,c3,c2,c1)=…
Ancak ikincisi yinelenen sürümleri geride bırakır:

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

d^xSonunda ne zaman hesaplanır c4bir ddahaki sefere çok daha yinelenen bir sürümünü alacaktır . c4^xSonunda ne zaman hesaplanır c3çok daha yinelenen bir sürümünü alacak c4,…
Bu gerçekten güçlü bir yineleme sürümü oluşturur çünküd :

1. geliştirir bKullanarakc0
2. geliştirir c0Kullanarakb
3. Kullanarak tüm iç katmanları iyileştirir b kendilerini geliştirir, bu daha fazla yinelendiğinde d daha güçlü hale gelir.

Bu uzun c zincirini yaratmak ne 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]yapar. Sadece verecek olan bypass etmek için
kullanır . c0^xc0d
[1]Sonunda ikinci çıkışını dönecektir demekse d^…. Yani b^….

Bu noktada, girdiyi arttırmak dışında çıktısını önemli ölçüde artırmak için e (x) ile ilgili bir şey düşünemedim.

Bu nedenle f(x,a)=a(x),e(a(x))(x,a)[1](x), daha iyi bir temel işlev çıkışı için b^…oluşturulan tarafından kullanılır ve e(x)daha e(x)büyük bir girişle aramak için bu temel işlevi kullanır .

g(x)=e(x)(x,f)[1](x,a)[1](x)e(x)yuvalamak için bir final kullanırf ve gerçekten güçlü bir işlev üretir.

Fgh yaklaşımı

Bu sayıyı her tür fgh ile yaklaştırmak için yardıma ihtiyacım olacak.

Eski versiyon : f _{ω ^{ω 6}} (f _{ω ^{ω 5}} (9e999)), Çevrimiçi deneyin! Açıklamanın revizyon geçmişi

Yakut, f _{ε 0 2} (5), 271 bayt

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]

Çevrimiçi deneyin!

Bu, m (n) haritasına dayanmaktadır .

Açıklama:

m[0][f0][k] = f0[f0[...f0[k]...]]ile kyineleme f0.

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]ile kyineleme f0.

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]ile kyineleme f0.

Genel olarak, argümanları m[n]alır n+2, ilk argümanı yineler f0,k katı ikinci bağımsız değişken üzerine, ve daha sonra üçüncü bağımsız üzerine elde edilen fonksiyonu uygular (varsa) (varsa), daha sonra, dördüncü bağımsız değişken üzerine elde edilen fonksiyonu uygular, vb.

Örnekler

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

Genel olarak 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

Genel olarak 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

Genel olarak, m[1][m[0]][n↦n+1] = f_ωhızla büyüyen hiyerarşide.

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

ve son çıktı

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