Một số bạn có thể quen thuộc với BigNum Bakeoff , kết thúc khá thú vị. Mục tiêu ít nhiều có thể được tóm tắt là viết chương trình C mà đầu ra của nó sẽ là lớn nhất, trong một số hạn chế và điều kiện lý thuyết, ví dụ như một máy tính có thể chạy chương trình.

Theo cùng một tinh thần, tôi đang đặt ra một thách thức tương tự mở ra cho tất cả các ngôn ngữ. Các điều kiện là:

• Tối đa 512 byte .

• Kết quả cuối cùng phải được in thành STDOUT. Đây là điểm số của bạn. Nếu nhiều số nguyên được in, chúng sẽ được nối.

• Đầu ra phải là một số nguyên. (Lưu ý: Infinity không phải là số nguyên .)

• Không có hằng số tích hợp nào lớn hơn 10, nhưng chữ số / chữ số vẫn ổn (ví dụ: hằng số Avogadro (là hằng số tích hợp) không hợp lệ, nhưng 10000 thì không.)

• Chương trình phải chấm dứt khi được cung cấp đủ tài nguyên để chạy.

• Đầu ra được in phải có tính xác định khi được cung cấp đủ tài nguyên để chạy.

• Bạn được cung cấp số nguyên hoặc số lượng lớn đủ lớn để chương trình của bạn chạy. Ví dụ: nếu chương trình của bạn yêu cầu áp dụng các thao tác cơ bản cho các số nhỏ hơn 10 ^1.000.000 , thì bạn có thể cho rằng máy tính đang chạy này có thể xử lý các số ít nhất lên tới 10 ^1.000.000 . (Lưu ý: Chương trình của bạn cũng có thể được chạy trên máy tính xử lý số lượng lên tới 10 ^2.000.000 , do đó, chỉ cần gọi số nguyên tối đa mà máy tính có thể xử lý sẽ không dẫn đến kết quả xác định.)

• Bạn được cung cấp đủ sức mạnh tính toán để chương trình của bạn hoàn thành việc thực hiện trong vòng dưới 5 giây. (Vì vậy, đừng lo lắng nếu chương trình của bạn đã chạy được một giờ trên máy tính của bạn và sẽ không hoàn thành sớm bất cứ lúc nào.)

• Không có tài nguyên bên ngoài, vì vậy đừng nghĩ đến việc nhập chức năng Ackermann đó trừ khi nó được tích hợp sẵn.

Tất cả các vật phẩm ma thuật đang được mượn tạm thời từ một vị thần hào phóng.

Vô cùng lớn với giới hạn không xác định

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

Trong đó B³F là giáo phẩm Church-Kleene với trình tự cơ bản là

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

Bảng xếp hạng:

1. Đơn giản chỉ cần đẹp Nghệ thuật , 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 e _{w ^{w 6}} (f _{w ^{w 5}} (9e999))

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

6. Nghệ thuật đơn giản đẹp , Ruby f _{ω + 35} (9 ^{9 99} )

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

Một số lưu ý phụ:

Nếu chúng tôi không thể xác minh điểm của bạn, chúng tôi không thể đưa nó lên bảng xếp hạng. Vì vậy, bạn có thể muốn giải thích chương trình của bạn một chút.

Tương tự như vậy, nếu bạn không hiểu số lượng của bạn lớn như thế nào, hãy giải thích chương trình của bạn và chúng tôi sẽ cố gắng giải quyết nó.

Nếu bạn sử dụng loại chương trình số của Trình tải , tôi sẽ đặt bạn vào một danh mục riêng gọi là "Cực kỳ lớn với giới hạn không xác định" , vì số của Trình tải không có giới hạn trên không tầm thường về mặt phân cấp phát triển nhanh cho ' tiêu chuẩn 'trình tự cơ bản.

Số sẽ được xếp hạng thông qua hệ thống phân cấp phát triển nhanh .

Đối với những người muốn tìm hiểu cách sử dụng hệ thống phân cấp đang phát triển nhanh để ước tính số lượng thực sự lớn, tôi đang lưu trữ một máy chủ Discord chỉ vì điều đó. Ngoài ra còn có một phòng trò chuyện: Pháp lệnh .

Những thách thức tương tự:

Số lượng lớn nhất có thể in

Golf một số lớn hơn TREE (3)

Chương trình kết thúc ngắn nhất có kích thước đầu ra vượt quá số của Graham

Đối với những người muốn xem một số chương trình đơn giản tạo ra hệ thống phân cấp phát triển nhanh cho các giá trị nhỏ, thì đây là:

Ruby: hệ thống phân cấp phát triển nhanh

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

Vân vân.

Để đi từ f_xđến f_(x+1), chúng tôi thêm một vòng lặp của n.times{...}.

Mặt khác, chúng ta chéo với tất cả các ví dụ trước

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)

Vân vân.

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

nơi M là Mahlo đầu tiên 'thứ', X là chi function (Mahlo sụp đổ chức năng), và ψ là hàm thứ sụp đổ.

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

Hãy thử trực tuyến!

Sự cố 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

Phân tích toán học:

fgiảm adựa trên n,b,q.

Ý tưởng cơ bản là có một cực kỳ lồng nhau avà giảm nó nhiều lần cho đến khi nó giảm xuống a=0. Để đơn giản, hãy để

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

Bây giờ, chúng ta chỉ lo lắng về n.

Đối với bất kỳ số nguyên nào k, chúng tôi nhận được f[k,n]=k-1, vì vậy chúng tôi có thể thấy rằng

g[k,n]=n+k

Sau đó chúng tôi có, đối với bất kỳ d, f[[0,d],n]=nvì vậy chúng tôi có thể thấy rằng

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

Chúng tôi sau đó có, cho bất kỳ c,d,e, f[[c,0,e],n]=f[[c,d,0],n]=c. Ví dụ,

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

Sau đó, chúng tôi có, cho bất kỳ trường hợp nào c,d,emà nó không rơi vào trường hợp trước đó , f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e]. Đây là nơi nó bắt đầu trở nên phức tạp. Một vài ví dụ:

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

Nó nhanh chóng tăng tốc từ đó. Một số điểm quan tâm:

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.

Cuối cùng, giới thiệu nhiều đối số của fhàm cũng như nhiều trường hợp hơn cho mảng cho phép chúng ta vượt qua hầu hết các ký hiệu tính toán được đặt tên. Một số đặc biệt được biết đến:

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

Bình thường, 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)

Yêu cầu bất kỳ đầu vào không trống, nhưng giá trị của chúng không được sử dụng.

Giải thích (cho phiên bản mới và thực sự - ghi điểm hợp lý ):

=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

Tôi rất khó tính toán kích thước của nó, chủ yếu là vì vào cuối ngày và tôi không quen thuộc lắm với hệ thống phân cấp đang phát triển nhanh hoặc tôi thậm chí còn cố gắng tìm hiểu xem Q đã trải qua bao nhiêu lần y()máy vắt. Mặc dù bây giờ tôi biết nhiều hơn về các thứ tự, tôi vẫn không biết làm thế nào để tính giá trị của thứ tự được biểu thị bằng định nghĩa đệ quy trong chương trình của tôi. Tôi đã tham gia máy chủ Discord, nhưng với bút danh Tôi không muốn liên kết với tên thật của mình.

Thật không may, vì tôi biết tương đối ít về các hệ thống phân cấp đang phát triển nhanh, tôi có khả năng đã bị mất câu trả lời của Ruby. Thật khó cho tôi để nói. Tôi có thể đã đánh bại câu trả lời của Ruby, nhưng tôi không chắc chắn 100%. ¯ \ _ (ツ) _ /

Bình thường, f _{3 + σ -1 + ²} (256 ²⁶ )

Trong đó σ _m [n] là hàm Busy Beaver Σ của lệnh mđược gọi trên n: σ _m [n] = _m (n). Thứ tự -1là để biểu thị rằng Busy Beaver ở đây không được gọi trên một Turing Machine thực sự, mà là một xấp xỉ với một băng quấn các Qphần tử hữu hạn . Điều này cho phép giải quyết vấn đề tạm dừng cho các chương trình này.

=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 là điều này tạo ra tất cả các chương trình BrainF ** k có thể có độ dài Q, chạy chúng trong môi trường có giá trị tối đa của một số nguyên là Q và độ dài băng là Q và biên dịch tất cả các trạng thái từ các hoạt động này với nhau append (đó là 3+) đến Q, lặp đi lặp lại trên trên thang điểm từ f _{ω ²} .

Tôi vẫn còn ~ một nửa số nhân vật để làm việc nếu tôi muốn làm gì đó nhiều hơn, nhưng cho đến khi chúng tôi tìm ra nơi này tôi sẽ để nó như vậy.

trăn, 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

Đây thực sự không phải là một câu trả lời hợp lệ, nhưng dù sao tôi cũng muốn đăng nó. Một danh sách nhanh chóng:

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

Dù sao, tôi không biết câu trả lời này có hợp pháp không, nhưng thật vui khi viết. Vui lòng chỉnh sửa bất kỳ lỗi nào bạn tìm thấy trong mã.

Ruby, có lẽ ~ 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

Hãy thử trực tuyến!

Giải thích toán học gần đúng:

Phần bên dưới xấp xỉ bằng chương trình trên, nhưng được đơn giản hóa để dễ hiểu hơn.

G(0,k) = k là chức năng cơ bản của chúng tôi.

Để đánh giá G(n,k), chúng tôi lấy kvà viết nó như G(n-1,1) + ... + G(n-2,1) + ... + G(0,1).

Sau đó thay đổi tất cả các G(x,1)thành G(x,2)và trừ 1vào toàn bộ kết quả.

Viết lại nó ở dạng trên bằng cách sử dụng G(x,2), ở đâu x<nvà để lại phần còn lại ở cuối. Lặp lại, thay đổi G(x,2)đến G(x,3)vv

Khi kết quả đạt được -1, trả về cơ sở ( bđó sẽ là G(x,b).)

Ví dụ:

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

Làm một số phép toán, tôi thấy rằng

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

Và hơn thế nữa, nó có xu hướng có một chút lông.

Nói chung, chúng tôi có

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

Tôi sẽ nhận được một lời giải thích sớ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)

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Giải trình

Python 3 là một ngôn ngữ đệ quy thực sự, điều này có nghĩa là không chỉ một hàm có thể tự gọi, một hàm cũng có thể lấy các hàm khác làm các hàm đầu vào hoặc đầu ra. Sử dụng các chức năng để làm cho bản thân tốt hơn là những gì chương trình của tôi dựa trên.

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

Định nghĩa

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)

Định nghĩa giải thích

a(x)=9^x a là hàm cơ sở, tôi chọn hàm này vì x> 0 => a (x)> x` mà tránh các điểm cố định.

b(x,f)=a(x), f^xb là chức năng cải tiến chung, nó có bất kỳ chức năng nào và đưa ra phiên bản tốt hơn của nó. b thậm chí có thể được áp dụng cho chính nó:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

nhưng để sử dụng đầy đủ sức mạnh của bviệc cải thiện, bbạn cần lấy đầu ra của b và sử dụng nó làm b mới, đây là những gì c0 làm:

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

hàm c (n) tổng quát hơn lấy n đối số cuối cùng (bắt đầu từ 0) c(1)(…,f,a)=f(…,f,a)và c(2)(…,f,a,b)=f(…,f,a,b). *lcó nghĩa là l là một mảng và l[~n]lấy n đối số cuối cùng

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in ld sử dụng c0 để nâng cấp b và b để nâng cấp tất cả các hàm đầu vào khác (trong đó có thể có bất kỳ số tiền nào vì danh sách)
d(x,b,c,d)>9^x,b^x,c^x,d^xvàd²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

nhưng d thậm chí còn tốt hơn nếu bạn kết hợp nó với 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)=…

bạn càng thêm c (x) vào cuối thì nó càng trở nên mạnh mẽ. C0 đầu tiên luôn luôn là 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)=…
Nhưng các phiên bản thứ hai bỏ lại phía sau:

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

Khi d^xcuối cùng được tính toán c4sẽ có phiên bản lặp lại nhiều hơn dvào lần tiếp theo. Khi c4^xđược tính toán cuối cùng c3sẽ có phiên bản lặp nhiều hơn của c4,
Điều này tạo ra một phiên bản lặp thực sự mạnh mẽ bởi vì d:

1. Cải thiện bviệc sử dụngc0
2. Cải thiện c0việc sử dụngb
3. Cải thiện tất cả các lớp lồng nhau bằng cách sử dụng b Cải thiện bản thân cải thiện, điều này có nghĩa là d trở nên mạnh mẽ hơn khi được lặp lại nhiều hơn.

Tạo chuỗi c dài này là những gì 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].
Nó sử dụng c0^xđể bỏ qua mà c0sẽ chỉ cung cấp d.
Có [1]nghĩa là cuối cùng nó sẽ trả lại đầu ra thứ hai của d^…. Vì vậy b^….

Tại thời điểm này, tôi không thể nghĩ ra bất kỳ điều gì phải làm với e (x) để tăng đáng kể sản lượng của nó ngoại trừ tăng đầu vào.

Vì vậy, f(x,a)=a(x),e(a(x))(x,a)[1](x)sử dụng hàm b^…được tạo bởi e(x)để xuất ra hàm cơ sở tốt hơn và sử dụng hàm cơ sở đó để gọi e(x)với đầu vào lớn hơn.

g(x)=e(x)(x,f)[1](x,a)[1](x)sử dụng một cái cuối cùng e(x)để làm tổ fvà tạo ra một chức năng thực sự mạnh mẽ.

Xấp xỉ

Tôi sẽ cần trợ giúp xấp xỉ con số này với bất kỳ loại fgh nào.

Phiên bản cũ : f _{w ^{w 6}} (f _{w ^{w 5}} (9e999)), Thử trực tuyến! Sửa đổi lịch sử giải thích

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]

Hãy thử trực tuyến!

Điều này dựa trên bản đồ m (n) .

Giải trình:

m[0][f0][k] = f0[f0[...f0[k]...]]với số klần lặp của f0.

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]với số klần lặp của f0.

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]với số klần lặp của f0.

Nói chung, m[n]tham gia vào các n+2đối số, lặp lại đối số thứ nhất f0, klần vào đối số thứ hai và sau đó áp dụng hàm kết quả cho đối số thứ ba (nếu nó tồn tại), sau đó áp dụng hàm kết quả cho đối số thứ tư (nếu nó tồn tại), Vân vân.

Ví dụ

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

Nói chung , 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

Nói chung , 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

Nói chung, m[1][m[0]][n↦n+1] = f_ωtrong hệ thống phân cấp phát triển nhanh.

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

và đầu ra cuối cùng là

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