บางคนอาจคุ้นเคยกับBigNum Bakeoffซึ่งจบลงด้วยความน่าสนใจ เป้าหมายสามารถสรุปได้มากหรือน้อยเมื่อเขียนโปรแกรม C ที่ผลลัพธ์จะใหญ่ที่สุดภายใต้ข้อ จำกัด และเงื่อนไขทางทฤษฎีเช่นคอมพิวเตอร์ที่สามารถเรียกใช้โปรแกรมได้

ในจิตวิญญาณเดียวกันฉันวางความท้าทายที่คล้ายกันเปิดให้ทุกภาษา เงื่อนไขคือ:

• สูงสุด 512 ไบต์

• ต้องพิมพ์ผลลัพธ์สุดท้ายไปที่ STDOUT นี่คือคะแนนของคุณ หากมีการพิมพ์จำนวนเต็มจำนวนมากพวกมันจะถูกต่อกัน

• เอาต์พุตต้องเป็นจำนวนเต็ม (หมายเหตุ: อินฟินิตี้ไม่ใช่จำนวนเต็ม )

• ไม่มีค่าคงที่แบบบิวด์อินที่ใหญ่กว่า 10 แต่ตัวเลข / หลักนั้นดี (เช่นค่าคงที่ของ Avogadro (ค่าคงที่ในตัว) ไม่ถูกต้อง แต่ไม่ใช่ 10,000

• โปรแกรมจะต้องยุติเมื่อมีทรัพยากรเพียงพอที่จะเรียกใช้

• เอาต์พุตที่พิมพ์ออกมาจะต้องถูกกำหนดไว้ล่วงหน้าเมื่อมีทรัพยากรเพียงพอในการทำงาน

• คุณได้รับจำนวนเต็มหรือบิ๊กพอที่เพียงพอเพื่อให้โปรแกรมของคุณทำงาน ตัวอย่างเช่นถ้าโปรแกรมของคุณต้องการการใช้งานพื้นฐานไปยังหมายเลขที่มีขนาดเล็กกว่า 10 ^1,000,000แล้วคุณอาจคิดคอมพิวเตอร์ที่ใช้นี้สามารถจัดการกับตัวเลขอย่างน้อยถึง 10 1,000,000 (หมายเหตุ: โปรแกรมของคุณอาจทำงานบนคอมพิวเตอร์ที่จัดการตัวเลขสูงถึง 10 ^2,000,000ดังนั้นการเรียกเลขจำนวนเต็มที่สูงสุดที่คอมพิวเตอร์สามารถจัดการได้จะไม่ส่งผลให้เกิดผลลัพธ์ที่กำหนดขึ้น)

• คุณได้รับพลังการประมวลผลที่เพียงพอสำหรับโปรแกรมของคุณในการดำเนินการให้เสร็จสิ้นภายใน 5 วินาที (ดังนั้นไม่ต้องกังวลหากโปรแกรมของคุณทำงานเป็นเวลาหนึ่งชั่วโมงในคอมพิวเตอร์ของคุณและจะไม่เสร็จเร็ว ๆ นี้ทุกเวลา)

• ไม่มีแหล่งข้อมูลภายนอกดังนั้นอย่าคิดนำเข้าฟังก์ชั่น Ackermann เว้นแต่จะเป็นแบบในตัว

ไอเท็มเวทย์มนตร์ทั้งหมดถูกยืมชั่วคราวจากเทพผู้ใจดี

มีขนาดใหญ่มากพร้อมขีด จำกัด ที่ไม่รู้จัก

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

โดยที่B³Fเป็นลำดับของ Church-Kleene กับลำดับขั้นพื้นฐานของ

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

ลีดเดอร์บอร์ด:

1. ซิมเพิลอาร์ทสวย , ทับทิม f _{ψ 0 (X (Ω M + X (Ω M + 1 ^{Ω M + 1} ) )) + 29} (9 ^{9 9} )

2. สตีเว่น H , Pythฉ _{ψ (โอห์ม^{โอห์ม} ) + ω² + 183} (256 ^27! )

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

4. fejfo , Python 3ฉ_{โอห์ม^{โอห์ม6}} (ฉ_{โอห์ม^{โอห์ม5}} (9e999))

5. สตีเว่น H , Python 3ฉ_{โอห์ม^{โอห์ม} + ω²} (9 ^{9 9 99} )

6. ซิมเพิลอาร์ทสวย , ทับทิม f _{ω + 35} (9 ^{9 99} )

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

หมายเหตุด้านข้างบางส่วน:

หากเราไม่สามารถตรวจสอบคะแนนของคุณได้เราจะไม่สามารถวางลงบนลีดเดอร์บอร์ดได้ ดังนั้นคุณอาจต้องการอธิบายโปรแกรมของคุณสักเล็กน้อย

ในทำนองเดียวกันหากคุณไม่เข้าใจว่าจำนวนของคุณมากเพียงใดให้อธิบายโปรแกรมของคุณแล้วเราจะพยายามทำให้สำเร็จ

หากคุณใช้โปรแกรมประเภทหมายเลขของ Loaderฉันจะจัดให้คุณอยู่ในหมวดหมู่แยกต่างหากที่เรียกว่า"ขนาดใหญ่มากพร้อมขีด จำกัด ที่ไม่รู้จัก"เนื่องจากหมายเลขของ Loader นั้นไม่มีขอบเขตบนที่ไม่สำคัญในแง่ของลำดับชั้นที่เติบโตอย่างรวดเร็วสำหรับ ' มาตรฐาน 'ลำดับขั้นพื้นฐาน

ตัวเลขจะถูกจัดอันดับผ่านลำดับชั้นที่เติบโตอย่างรวดเร็ว

สำหรับผู้ที่ต้องการเรียนรู้วิธีการใช้ลำดับชั้นที่เติบโตอย่างรวดเร็วเพื่อประมาณจำนวนมากจริงๆฉันโฮสต์เซิร์ฟเวอร์ Discordเพียงแค่นั้น นอกจากนี้ยังมีห้องสนทนา: Ordinality

ความท้าทายที่คล้ายกัน:

พิมพ์ได้จำนวนมากที่สุด

ตีกอล์ฟให้ใหญ่กว่า TREE (3)

โปรแกรมยกเลิกที่สั้นที่สุดที่ขนาดเอาต์พุตเกินจำนวนของ Graham

สำหรับผู้ที่ต้องการเห็นโปรแกรมง่าย ๆ บางอย่างที่ให้ลำดับชั้นที่เติบโตอย่างรวดเร็วสำหรับค่าเล็ก ๆ นี่คือ:

Ruby: ลำดับชั้นที่เติบโตอย่างรวดเร็ว

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

เป็นต้น

ที่จะไปจากf_xการที่เราเพิ่มอีกหนึ่งวงของf_(x+1)n.times{...}

มิเช่นนั้นเราจะตัดทแยงมุมเทียบกับตัวอย่างก่อนหน้าทั้งหมด

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)

เป็นต้น

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

ที่เอ็มเป็นครั้งแรกที่ Mahlo 'ลำดับ' Xเป็นฟังก์ชั่นไค (Mahlo ฟังก์ชั่นการยุบ) และψเป็นลำดับฟังก์ชั่นการยุบ

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

ลองออนไลน์!

การวิเคราะห์รหัส:

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

รายละเอียดทางคณิตศาสตร์:

fลดขึ้นอยู่กับan,b,q

ความคิดพื้นฐานคือการมีซ้อนกันมากaและลดความมันซ้ำ ๆ a=0จนกว่ามันจะลดลงไป เพื่อความง่ายให้

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

nสำหรับตอนนี้ขอเพียงความกังวลเกี่ยวกับ

สำหรับจำนวนเต็มใด ๆkเราได้f[k,n]=k-1ดังนั้นเราจะเห็นได้ว่า

g[k,n]=n+k

จากนั้นเราจะมีสำหรับการใด ๆd, f[[0,d],n]=nดังนั้นเราจะเห็นว่า

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

จากนั้นเราจะมีสำหรับการใด ๆ,c,d,e f[[c,0,e],n]=f[[c,d,0],n]=cตัวอย่างเช่น,

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

เรามีแล้วสำหรับสิ่งc,d,eที่ไม่ได้ตกอยู่ในกรณีก่อนหน้านี้, f[[c,d,e],n]=[[c,d,f[e,n]],f[d,n],e]. นี่คือจุดที่มันเริ่มซับซ้อน ตัวอย่างบางส่วน:

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

มันเพิ่มขึ้นอย่างรวดเร็วจากที่นั่น บางจุดที่น่าสนใจ:

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.

ในที่สุดการแนะนำการขัดแย้งกันของfฟังก์ชั่นเช่นเดียวกับกรณีอื่น ๆ สำหรับอาเรย์จะช่วยให้เราสามารถผ่านสัญลักษณ์ที่คำนวณได้ บางคนรู้จักโดยเฉพาะ:

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 ฉ_{ψ (โอห์ม^{โอห์ม} ) + ω ² 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)

ต้องการอินพุตที่ไม่ว่าง แต่ไม่ได้ใช้ค่าดังกล่าว

คำอธิบาย (สำหรับเวอร์ชันใหม่และให้คะแนนตามจริง ):

=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

มันยากมากสำหรับฉันในการคำนวณขนาดของสิ่งนี้ส่วนใหญ่เป็นเพราะมันสายในตอนกลางวันและฉันไม่คุ้นเคยกับลำดับชั้นที่เติบโตอย่างรวดเร็วหรือฉันจะลองคิดดูว่า Q ผ่านไปกี่ครั้งy()wringer ในขณะที่ฉันรู้เพิ่มเติมเกี่ยวกับเลขลำดับฉันก็ยังไม่รู้ว่าจะคำนวณค่าของลำดับที่แสดงโดยนิยามแบบเรียกซ้ำในโปรแกรมของฉันได้อย่างไร ฉันเข้าร่วมเซิร์ฟเวอร์ Discord แต่ภายใต้นามแฝงฉันไม่ควรเชื่อมโยงกับชื่อจริงของฉัน

น่าเสียดายที่ฉันรู้น้อยมากเกี่ยวกับลำดับขั้นที่เพิ่มขึ้นอย่างรวดเร็วฉันจึงแพ้คำตอบ Ruby ไปแล้ว มันยากสำหรับฉันที่จะบอก ฉันอาจเอาชนะคำตอบทับทิม แต่ฉันไม่แน่ใจ 100% ¯ \ _ (ツ) _ / ¯

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

โดยที่σ _m [n] คือฟังก์ชัน Busy Beaver order ของคำสั่งที่mเรียกใช้บนn: σ _m [n] = Σ _m (n) คำสั่ง-1คือแสดงว่า Busy Beaver ที่นี่ไม่ได้ถูกเรียกบนเครื่องทัวริงที่แท้จริง แต่เป็นการประมาณด้วยเทปพันห่อQองค์ประกอบ สิ่งนี้จะช่วยให้ปัญหาการหยุดชะงักสามารถแก้ไขได้สำหรับโปรแกรมเหล่านี้

=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 คือสิ่งนี้สร้าง BrainF ** k โปรแกรมทั้งหมดที่เป็นไปได้ของความยาว Q รันในสภาพแวดล้อมที่ค่าสูงสุดของจำนวนเต็มคือ Q และความยาวเทปคือ Q และรวบรวมสถานะทั้งหมดจากการดำเนินการเหล่านี้เข้าด้วยกัน ผนวก (ที่3+) ไปถามซ้ำข้างต้นโย f เป็น_ω 2

ฉันยังมีตัวละครอีกครึ่งตัวที่จะทำงานด้วยถ้าฉันต้องการทำอะไรมากกว่านี้ แต่จนกว่าเราจะรู้ว่านี่คือที่ไหนฉันจะปล่อยให้เป็นแบบนั้น

หลาม, f ₃ (f ₃ (141)), 512 ไบต์

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

นี่ไม่ใช่คำตอบที่ถูกต้อง แต่ฉันต้องการโพสต์ต่อไป บทสรุปอย่างรวดเร็ว:

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

อย่างไรก็ตามฉันไม่รู้ว่าคำตอบนี้ถูกต้องตามกฎหมายในทางเทคนิคหรือไม่ แต่ก็สนุกดีที่จะเขียน อย่าลังเลที่จะแก้ไขข้อผิดพลาดที่คุณพบในรหัส

ทับทิมอาจเป็น ~ 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

ลองออนไลน์!

คำอธิบายคณิตศาสตร์โดยประมาณ:

ด้านล่างมีค่าประมาณเท่ากับโปรแกรมด้านบน แต่ลดความซับซ้อนเพื่อให้เข้าใจได้ง่ายขึ้น

G(0,k) = k เป็นฟังก์ชันพื้นฐานของเรา

เพื่อประเมินG(n,k)เราใช้และเขียนเป็นkG(n-1,1) + ... + G(n-2,1) + ... + G(0,1)

จากนั้นเปลี่ยนค่าทั้งหมดให้G(x,1)เป็นG(x,2)และลบออก1จากผลลัพธ์ทั้งหมด

เขียนซ้ำในแบบฟอร์มข้างต้นโดยใช้G(x,2)ที่ไหนx<nและปล่อยให้ส่วนที่เหลืออยู่ท้าย ทำซ้ำเปลี่ยนG(x,2)เป็นG(x,3)ฯลฯ

เมื่อผลลัพธ์มาถึง-1ให้ส่งคืนฐาน ( bที่จะเป็นG(x,b))

ตัวอย่าง:

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

เมื่อทำคณิตศาสตร์ฉันพบว่า

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

และยิ่งกว่านั้นมันมักจะมีขนดก

โดยทั่วไปเรามี

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

งูหลาม 3 ฉ_{ω ^ω + ωω *} (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))

ฉันจะอธิบายให้เร็วขึ้น

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)

ลองออนไลน์!

Python 3, 323 ไบต์, 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 '))

ลองออนไลน์!

คำอธิบาย

Python 3 เป็นภาษาแบบเรียกซ้ำอย่างแท้จริงซึ่งหมายความว่าไม่เพียง แต่จะสามารถเรียกใช้ฟังก์ชันได้เท่านั้น แต่ยังสามารถใช้ฟังก์ชั่นอื่นเป็นฟังก์ชั่นอินพุตหรือเอาต์พุต การใช้ฟังก์ชั่นเพื่อทำให้ตัวเองดีขึ้นคือสิ่งที่โปรแกรมของฉันใช้

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

คำนิยาม

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)

คำอธิบายความหมาย

a(x)=9^x a คือฟังก์ชั่นพื้นฐานฉันเลือกฟังก์ชั่นนี้เพราะ x> 0 => a (x)> x` ซึ่งหลีกเลี่ยงจุดคงที่

b(x,f)=a(x), f^xb เป็นฟังก์ชั่นการปรับปรุงทั่วไปที่ใช้ในฟังก์ชั่นใด ๆ และส่งออกเวอร์ชันที่ดีกว่าของมัน b สามารถนำไปใช้กับตัวเองได้:b(x,b)[1]=b^x b(x,b^x)[1]=b^(x*x)

แต่หากต้องการใช้พลังของbการปรับปรุงอย่างเต็มที่bคุณจำเป็นต้องใช้เอาต์พุตของ b และใช้เป็น b ใหม่นี่คือสิ่งที่ c0 ทำ:

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

คทั่วไปมากขึ้น (n) ฟังก์ชั่นใช้เวลาอาร์กิวเมนต์ n ที่ผ่านมา (เริ่มจาก 0) ดังนั้น และc(1)(…,f,a)=f(…,f,a) หมายถึง l เป็นอาร์เรย์และรับอาร์กิวเมนต์สุดท้ายc(2)(…,f,a,b)=f(…,f,a,b)*ll[~n]

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in ld ใช้ c0 เพื่ออัพเกรด b และ b เพื่ออัพเกรดฟังก์ชั่นอินพุตอื่น ๆ ทั้งหมด (ซึ่งอาจมีจำนวนเท่าใดก็ได้เนื่องจากรายการ)
d(x,b,c,d)>9^x,b^x,c^x,d^xและd²(x,b,c,d)>a²(x), b^(9↑↑x), c^(9↑↑x), d^(9↑↑x)

แต่จะดีขึ้นถ้าคุณรวมเข้ากับ 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)=…

ยิ่งคุณเพิ่ม c (x) ในตอนท้ายมันก็จะยิ่งมีพลังมากขึ้น c0 แรกยังคงอยู่เสมอ 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)=…
แต่อันที่สองปล่อยให้ทำซ้ำเวอร์ชันที่อยู่เบื้องหลัง:

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^xมีการคำนวณในที่สุดก็c4จะใช้รุ่นซ้ำdอีกครั้งในครั้งต่อไป c4^xในที่สุดเมื่อมีการคำนวณแล้วc3จะใช้เวอร์ชันที่ซ้ำแล้วซ้ำอีกของc4...
สิ่งนี้จะสร้างเวอร์ชันการทำซ้ำที่ทรงพลังเพราะd:

1. ปรับปรุงการbใช้c0
2. ปรับปรุงการc0ใช้b
3. ปรับปรุงเลเยอร์ทั้งหมดของการทำรังโดยใช้b การปรับปรุงตัวเองซึ่งหมายความว่า d มีพลังมากขึ้นเมื่อทำซ้ำมากขึ้น

การสร้างสายโซ่ยาวของ c นี้คือสิ่งที่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]ทำ
โดยจะใช้c0^xในการบายพาสที่เพิ่งจะให้c0 หมายความว่าในที่สุดมันก็จะกลับมาเอาท์พุทที่สองของ ดังนั้นd
[1]d^…b^…

ณ จุดนี้ฉันไม่คิดว่าจะทำอะไรกับ e (x) เพื่อเพิ่มเอาต์พุตอย่างมีนัยสำคัญยกเว้นอินพุตที่เพิ่มขึ้น

ดังนั้นf(x,a)=a(x),e(a(x))(x,a)[1](x)ใช้b^…สร้างโดยe(x)เพื่อส่งออกฟังก์ชั่นฐานที่ดีขึ้นและใช้ฟังก์ชั่นฐานที่จะเรียกe(x)ด้วยการป้อนข้อมูลที่ใหญ่

g(x)=e(x)(x,f)[1](x,a)[1](x)ใช้ขั้นตอนสุดท้ายe(x)ในการซ้อนfและสร้างฟังก์ชันที่ทรงพลังจริงๆ

ประมาณ Fgh

ฉันต้องการความช่วยเหลือในการประมาณตัวเลขนี้ด้วย fgh ประเภทใดก็ได้

รุ่นเก่า : F _{โอห์ม^{โอห์ม6}} (ฉ_{โอห์ม^{โอห์ม5}} (9e999)) ลองออนไลน์! ประวัติการแก้ไขของคำอธิบาย

Ruby, f _{ε 0 2} (5), 271 ไบต์

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]

ลองออนไลน์!

นี้จะตามออกของเมตร (n) แผนที่

คำอธิบาย:

m[0][f0][k] = f0[f0[...f0[k]...]]ด้วยซ้ำkf0

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k]ด้วยซ้ำkf0

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]ด้วยซ้ำkf0

โดยทั่วไปm[n]ใช้ในการn+2โต้แย้งซ้ำอาร์กิวเมนต์แรกf0, kเวลาบนอาร์กิวเมนต์ที่สองแล้วใช้ฟังก์ชั่นที่เกิดขึ้นบนอาร์กิวเมนต์ที่สาม (ถ้ามี) จากนั้นใช้ฟังก์ชั่นที่เกิดขึ้นกับอาร์กิวเมนต์ที่สี่ (ถ้ามี) เป็นต้น

ตัวอย่าง

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

โดยทั่วไป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

โดยทั่วไป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

โดยทั่วไปm[1][m[0]][n↦n+1] = f_ωในลำดับชั้นที่เติบโตอย่างรวดเร็ว

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

และผลลัพธ์สุดท้ายเป็น

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