आप में से कुछ लोग BigNum Bakeoff से परिचित हो सकते हैं , जो काफी दिलचस्प तरीके से समाप्त हुआ। लक्ष्य को कम या ज्यादा किया जा सकता है एक सी प्रोग्राम लिखने के रूप में, जो कुछ बाधाओं और सैद्धांतिक परिस्थितियों के तहत सबसे बड़ा होगा, जैसे कि एक कंप्यूटर जो प्रोग्राम चला सकता है।

उसी भावना में, मैं सभी भाषाओं के लिए एक समान चुनौती प्रस्तुत कर रहा हूं। शर्तें हैं:

अधिकतम 512 बाइट्स ।
अंतिम परिणाम STDOUT को मुद्रित किया जाना चाहिए। यह आपका स्कोर है। यदि कई पूर्णांक मुद्रित होते हैं, तो उन्हें संक्षिप्त किया जाएगा।
आउटपुट एक पूर्णांक होना चाहिए। (नोट: अनंत एक पूर्णांक नहीं है ।)
कोई अंतर्निर्मित स्थिरांक 10 से बड़ा नहीं है, लेकिन अंक / अंक ठीक हैं (उदाहरण के लिए एवोगैडरो की स्थिरांक (एक अंतर्निहित स्थिरांक के रूप में) अमान्य है, लेकिन 10000 नहीं है।)
कार्यक्रम को तब समाप्त किया जाना चाहिए जब उसे चलाने के लिए पर्याप्त संसाधन उपलब्ध कराए जाएं।
मुद्रित आउटपुट को नियतात्मक होना चाहिए, जब चलाने के लिए पर्याप्त संसाधन उपलब्ध कराए जाएं।
आपके कार्यक्रम को चलाने के लिए आपको बड़े पर्याप्त पूर्णांक या बड़े चिह्न प्रदान किए जाते हैं। उदाहरण के लिए, अपने कार्यक्रम 10 से छोटी संख्या के लिए बुनियादी आपरेशन लागू करने की आवश्यकता है ^1000000 , तो आप कंप्यूटर इस कम से कम 10 नंबर संभाल कर सकते हैं चल रहा है मान सकते हैं ^1000000 । (नोट: आपका प्रोग्राम एक ऐसे कंप्यूटर पर भी चलाया जा सकता है, जो १० ^{२,०००,०००} तक की संख्या को संभालता है , इसलिए केवल अधिकतम पूर्णांक को कंप्यूटर पर कॉल करने से नियतात्मक परिणाम प्राप्त नहीं होंगे।)
आपको अपने प्रोग्राम को 5 सेकंड से कम समय में निष्पादित करने के लिए पर्याप्त कंप्यूटिंग शक्ति प्रदान की जाती है। (इसलिए चिंता न करें कि आपका प्रोग्राम आपके कंप्यूटर पर एक घंटे से चल रहा है और जल्द ही कभी भी समाप्त नहीं होगा।)
कोई बाहरी संसाधन नहीं है, इसलिए उस एकरमैन फ़ंक्शन को आयात करने के बारे में न सोचें जब तक कि यह एक अंतर्निहित न हो।

सभी जादुई वस्तुओं को एक उदार देवता से अस्थायी रूप से उधार लिया जा रहा है।

अज्ञात सीमा के साथ बहुत बड़ा

स्टीवन एच , पायथ f_{3 + B³F +} 256 (256²⁶ )

जहां B whereF मूल अनुक्रम के साथ चर्च-क्लेन अध्यादेश है

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

लीडरबोर्ड:

सीधे शब्दों में सुंदर कला , रूबी च_{ψ ₀ (एक्स (Ω _{एम + एक्स (Ω _{एम + 1}^{Ω _{एम + 1}} )} )) + 29} (9^{9 ⁹} )
स्टीवन एच , Pyth च_{ψ (Ω ^Ω ) + ω² + 183} (256^27! )
लीकी नून , अजगर 3 च_{ε ₀} (9^{9 ⁹} )
fejfo , अजगर 3 च_{ω ^{ω ⁶}} (च_{ω ^{ω ⁵}} (9e999))
स्टीवन एच , अजगर 3 च_{ω ^ω + ω²} (9^{9 ^{9 ⁹⁹}} )
सिंपल ब्यूटीफुल आर्ट , रूबी एफ_{35 + ३५} (^{९ ^९९}^९ )
i .. , पायथन 2 , एफ₃ (एफ₃ (141))

कुछ साइड नोट्स:

यदि हम आपके स्कोर को सत्यापित नहीं कर सकते, तो हम इसे लीडरबोर्ड पर नहीं डाल सकते। इसलिए आप अपने कार्यक्रम को थोड़ा समझाने की अपेक्षा कर सकते हैं।

इसी तरह, अगर आपको समझ नहीं आ रहा है कि आपका नंबर कितना बड़ा है, तो अपने प्रोग्राम की व्याख्या करें और हम इसे पूरा करने की कोशिश करेंगे।

यदि आप लोडर के नंबर प्रकार के प्रोग्राम का उपयोग करते हैं , तो मैं आपको एक अलग श्रेणी में रखूंगा जिसे "अज्ञात सीमा के साथ बहुत बड़ा" कहा जाता है , क्योंकि लोडर की संख्या में तेजी से बढ़ते पदानुक्रम के संदर्भ में एक गैर-तुच्छ ऊपरी सीमा नहीं है। मानक 'मौलिक अनुक्रम।

नंबर तेजी से बढ़ते पदानुक्रम के माध्यम से क्रमबद्ध होंगे ।

उन लोगों के लिए जो वास्तव में बड़ी संख्या के लिए तेजी से बढ़ते पदानुक्रम का उपयोग करना सीखना चाहते हैं, मैं सिर्फ उसके लिए एक डिस्कॉर्ड सर्वर की मेजबानी कर रहा हूं । एक चैट रूम भी है: साधारणता ।

इसी तरह की चुनौतियां:

सबसे बड़ी संख्या प्रिंट करने योग्य

TREE (3) से बड़ा एक गोल्फ

सबसे छोटा समाप्ति कार्यक्रम जिसका आउटपुट आकार ग्राहम की संख्या से अधिक है

उन लोगों के लिए जो कुछ सरल कार्यक्रमों को देखना चाहते हैं जो छोटे मूल्यों के लिए तेजी से बढ़ते पदानुक्रम का उत्पादन करते हैं, यहां वे हैं:

रूबी: तेजी से बढ़ती पदानुक्रम

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

आदि।

math code-challenge busy-beaver

— सिंपल ब्यूटीफुल आर्ट
स्रोत

क्या अंकों को अंतर्निहित स्थिरांक के रूप में गिना जाता है?

— PyRulez

3

@CloseVoters यह बहुत व्यापक कैसे हो सकता है ... ठीक है, उपयोगकर्ता को एक नंबर को असीम रूप से कई संख्याओं में आउटपुट करने के लिए कहना उपयोगकर्ता के असीम रूप से कई कार्यों में से एक को चुनने के लिए पूछने के समान नहीं है। निष्पक्ष होने के लिए यह सवाल उपयोगकर्ता को एक ही काम करने के लिए कहता है। पहले से ही व्यापक के रूप में 4 करीबी वोट ...

— user202729

1

@ Οurous हाँ, आप ऐसा मान सकते हैं। लेकिन महसूस करें कि जब आपके प्रोग्राम को और अधिक संसाधन दिए जाते हैं, जिसमें तेज संगणना भी शामिल है, तो आउटपुट का निर्धारण निर्धारक होना चाहिए।

— बस सुंदर कला

1

मैंने अन्य टिप्पणी अनुभाग में कहा कि मुझे क्यों लगता है कि ब्रेनफक बिजी बिवर फंक्शन घातांक होगा, लेकिन मैं इसे और अधिक जोड़ना चाहूंगा, मुझे नहीं लगता कि चर्च-क्लेने ऑर्डिनल किसी भी कंप्यूटर प्रोग्राम के लिए उपयुक्त स्तर होगा। । एक फ़ंक्शन एक प्रोग्राम के साथ कोड कर सकता है, जो कम्प्यूटेशनल हैं, और इसलिए कुछ पर्याप्त रूप से मजबूत पुनरावर्ती ध्वनि सिद्धांत के अस्थायी रूप से पुनरावर्ती कार्यों में आना चाहिए। उस सिद्धांत में एक पुनरावर्ती प्रमाण सिद्धांतिक क्रम होगा, और यह कार्य उचित मौलिक अनुक्रमों को मानते हुए FGH में उस क्रम से नीचे होगा।

— डिडलिट

1

बेशक वास्तविक व्यस्त बीवर फ़ंक्शन को प्रोग्राम (हाइपरकंप्यूटेशनल भाषाओं को एक तरफ) में कोडित नहीं किया जा सकता है, और प्रतिबंधित व्यस्त बीवर फ़ंक्शन जिन्हें प्रोग्राम किया जा सकता है, उन्हें आवश्यक रूप से धीमा होना चाहिए।

— डेडलिट

7

रूबी, च _{ψ ₀ (एक्स (Ω _{एम + एक्स (Ω _{एम + 1}^{Ω _{एम + 1}} )} )) + 29} (9 ^{9 ⁹} )

जहां एम पहला महालो 'ऑर्डिनल' है, वहीं एक्स चि चि फंक्शन (महलो कोलैप्सिंग फंक्शन) है, और ψ ऑर्डिनल कोलैप्सिंग फंक्शन है।

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के aआधार पर कम करता है n,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

— सिंपल ब्यूटीफुल आर्ट
स्रोत

1

साधारण व्याख्या?

— कैलक्यूलेटरफ्लोरलाइन

क्या यह आपकी सबसे बड़ी परिभाषित संख्या है? ऐसा प्रतीत होता है!

— thePlasmaRailgun

3

पायथ, एफ th _{(Ω ^Ω ) + ^{18 2} +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()रिंगर। जबकि मैं अब अध्यादेशों के बारे में अधिक जानता हूं, मुझे अभी भी पता नहीं है कि मेरे कार्यक्रम में पुनरावर्ती परिभाषा द्वारा प्रस्तुत अध्यादेश के मूल्य की गणना कैसे की जाए। मैं डिसॉर्ड सर्वर में शामिल हो जाऊंगा, लेकिन यह एक छद्म नाम के तहत है जो मैं अपने वास्तविक नाम से नहीं जुड़ा था।

दुर्भाग्य से, क्योंकि मैं तेजी से बढ़ते पदानुक्रमों के बारे में अपेक्षाकृत कम जानता हूं, मुझे रूबी के जवाब से पहले ही हारने की संभावना है। मेरे लिए बताना मुश्किल है। ~~मैंने रूबी के जवाब को पीटा हो सकता है, लेकिन मुझे 100% यकीन नहीं है।~~ ¯ \ _ (ツ) _ / ¯

— स्टीवन एच।
स्रोत

अगर मैं सही ढंग से समझूं, तो आपका स्कोर शायद कहीं के बॉलपार्क में है 27^^^27^^27^^4, या f4(27^^27^^4)) ≈ f4(f3(f3(19)))।

— बस

मैंने एक छोटा सा बदलाव किया है जो मुझे कल के बारे में सोचना चाहिए था, लेकिन किसी भी तरह से - बस के संचालन के बजाय yपर काम करने के लिए फिर से बनाना नहीं था । यह स्कोर को कैसे प्रभावित करता है? y(Q-1)Q

— स्टीवन एच।

1

मुझे पूरा यकीन नहीं है कि क्या चल रहा है। करता है y(Q) = L(y(Q-1)), प्रति से?

— बस सुंदर कला

1

मुझे लगता है कि हम एक चैट रूम में ऐसा करने से बेहतर भाग्य होगा ।

— स्टीवन एच।

@SimplyBeautifulArt इसके लिए शायद सबसे अच्छा नहीं है कि इसके लिए तेजी से बढ़ते पदानुक्रम संकेतन का उपयोग किया जाए, क्योंकि यह अपनी तरह का छोटा है।

— पाइरुलज

3

पायथ, एफ _{3 + + _-1 +} 256 _² (256 ²⁶ )

जहां Where _m [n] ऑर्डर का व्यस्त बीवर फ़ंक्शन है : mजिसे n _m [n] = ) _m (n) कहा जाता है। यह आदेश निरूपित करने के लिए है कि यहां व्यस्त बीवर को एक सही ट्यूरिंग मशीन पर नहीं बुलाया जा रहा है, बल्कि एक परिमित रैपिंग टेप के साथ एक सन्निकटन हैn-1Q तत्वों के । यह इन कार्यक्रमों के लिए हल करने की समस्या को हल करने की अनुमति देता है।

=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+) to Q, f को _{ω के} पैमाने पर ऊपर दोहरा रहा है_² ।

मेरे पास अभी भी ~ आधे पात्र हैं काम करने के लिए अगर मैं कुछ और करना चाहता था, लेकिन जब तक हम यह पता नहीं लगा लेते कि यह वह जगह है जहाँ मैं इसे छोड़ दूँगा।

— स्टीवन एच।
स्रोत

मैंने लीडरबोर्ड में I की एक बेहतर व्याख्या की।

— बस सुंदर कला

4

यह मुझे इस विशेष व्यस्त बीवर फ़ंक्शन की तरह नहीं दिखता है जो तेजी से बढ़ रहा है। 0 और Q के बीच Q पूर्णांकों की सीमा के साथ, प्रोग्राम में केवल (Q + 1) ^ Q संभव टेप, और Q संभावित स्थान हैं, इसलिए अधिकांश Q * (Q + 1) ^ Q संभावित राज्यों में हो सकते हैं एक चल कार्यक्रम। तो एक प्रोग्राम को Q * (Q + 1) ^ Q चरणों में रोकना चाहिए या बिल्कुल नहीं। संभावित कार्यक्रमों की संख्या भी एक घातीय ऊपरी सीमा द्वारा सीमित है। तो मुझे ऐसा लग रहा है कि इस व्यस्त बीवर फ़ंक्शन की एक घातीय ऊपरी सीमा है, और अंतिम फ़ंक्शन $ f _ {\ omega ^ 2} $ के आदेश पर होगा।

— डिडलिट

2

अजगर, एफ ₃ (एफ ₃ (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_3 (9) है, और यह निश्चित रूप से कानूनी है। for j in range(f(x)): for j in range(f(x)): x = f(x)हालांकि, घोंसले के शिकार से भी आपको एक बड़ी संख्या मिल जाएगी । में शामिल हों चैट क्यों चर्चा करने के लिए!

— स्टीवन एच।

यह एक मान्य उत्तर क्यों नहीं है?

— ब्यूटी आर्ट

मैं काफी नहीं था मिलता , सवाल तो मैं बस बना मैं क्या सोचा सही था।

— I ..

1

रूबी, शायद ~ एफ _{ω + ३५} ( ^{९ ^९९}^९ )

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), हम kइसे लेते हैं और लिखते हैं G(n-1,1) + ... + G(n-2,1) + ... + G(0,1)।

फिर सभी के G(x,1)'s' को बदलें G(x,2)और 1पूरे परिणाम से घटाएं ।

इसका उपर्युक्त रूप में उपयोग करें G(x,2), जहां x<n, और शेष को अंत में छोड़ दें। दोहराएँ, बदल रहा है G(x,2)करने के लिएG(x,3) , आदि

जब परिणाम पहुंचता है -1, तो आधार वापस करें (जो bकि अंदर होगा G(x,b))

उदाहरण:

जी (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

जी (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

जी (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

जी (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.

— सिंपल ब्यूटीफुल आर्ट
स्रोत

1

अजगर 3, एफ _{ω ^ω + ω *} 9 (9 ^{9 ^{9 ⁹⁹}} )

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

मुझे जल्द ही स्पष्टीकरण मिल जाएगा।

— स्टीवन एच।
स्रोत

1

अजगर 3 , ~ च _{ε ₀} (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)

इसे ऑनलाइन आज़माएं!

— लीक नन
स्रोत

N = 9 ** 9e99 थोड़ा बड़ा होना चाहिए

— fejfo

किसके जवाब से?

— लीक नन

मेरा मतलब है कि अगर आप N = 9 ** 9e99 के साथ पहले को बदलते हैं तो आउटपुट थोड़ा बड़ा होना चाहिए क्योंकि 9e99> 9 ** 9। बेशक यह अभी भी आपका जवाब है।

— fejfo

@ Fajfo मेरा मतलब है कि यह मेरी रैंकिंग नहीं बदलेगा।

— लीक

2

क्या वो वजह बन रही हे?

— fejfo

1

पायथन 3, 323 बाइट्स, जी 9 ^ई 9 (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 '))

इसे ऑनलाइन आज़माएं!

व्याख्या

पायथन 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)

अधिक सामान्य सी (एन) फ़ंक्शन एन अंतिम तर्क (0 से शुरू) c(1)(…,f,a)=f(…,f,a)और इसलिए लेता है c(2)(…,f,a,b)=f(…,f,a,b) । *lमतलब l एक सरणी है और l[~n]n अंतिम तर्क लेता है

d(x,b,c,*l)=a(x), c0(x,b), b(x,c0), b(x,f) for f in l d, अन्य सभी इनपुट फ़ंक्शंस को अपग्रेड करने के लिए b और b को अपग्रेड करने के लिए c0 का उपयोग करता है (जिनमें से सूची के कारण कोई भी राशि हो सकती है)
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 के साथ जोड़ते हैं तो d और भी बेहतर हो जाता है:
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)=…

अधिक सी (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:

bउपयोग में सुधारc0
c0उपयोग में सुधारb
घोंसले के शिकार की सभी परतों में b सुधार करता है सुधार में सुधार होता है, इसका मतलब यह है कि घ अधिक शक्तिशाली हो जाता है जब इसे और अधिक पुनरावृत्त किया जाता है।

सी की इस लंबी श्रृंखला को बनाने से क्या 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^… ।

इस बिंदु पर मैं ई (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 के साथ इस संख्या को समझने में मदद की आवश्यकता होगी।

पुराने संस्करण : च _{ω ^{ω ⁶}} (च _{ω ^{ω ⁵}} (9e999)), यह ऑनलाइन कोशिश करो! स्पष्टीकरण का संशोधन इतिहास

— fejfo
स्रोत

वास्तव में f_1(x) = x+x, लेकिन लंबे समय में, यह बहुत ज्यादा मायने नहीं रखता है।

— बस सुंदर कला

क्या आप अपने मौलिक दृश्यों को थोड़ा और समझा सकते हैं?

— बस सुंदर कला

@SimplyBeautifulArt ओउ हाँ मैं अद्यतन करने के लिए भूल गया कि मैं इसे से बदल दिया है x*x।

— fejfo

@SimplyBeautifulArt मेरा उत्तर किसी भी अध्यादेश का उपयोग नहीं करता है इसलिए मेरे लिए इसे अध्यादेशों के साथ समझाना कठिन है। मैं वास्तव में कर सकता हूँ मेरे कार्यों की परिभाषा दे और fgh में प्रभाव का एक अनुमान है। उदाहरण:a2(f_n)~=f_{n+1}

— fejfo

1

रूबी, एफ_{ε ₀ 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]

इसे ऑनलाइन आज़माएं!

यह m (n) मैप से आधारित है ।

स्पष्टीकरण:

m[0][f0][k] = f0[f0[...f0[k]...]]के kपुनरावृत्तियों के साथ f0।

m[1][f0][f1][k] = f0[f0[...f0[f1]...]][k] साथ में kपुनरावृत्तियों के f0।

m[2][f0][f1][f2][k] = f0[f0[...f0[f1]...]][f2][k]के kपुनरावृत्तियों के साथ f0।

सामान्य रूप में, 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]

— सिंपल ब्यूटीफुल आर्ट
स्रोत

BigNum Bakeoff रिबूट

अज्ञात सीमा के साथ बहुत बड़ा

लीडरबोर्ड:

कुछ साइड नोट्स:

रूबी: तेजी से बढ़ती पदानुक्रम

रूबी, च ψ 0 (एक्स (Ω एम + एक्स (Ω एम + 1 Ω एम + 1 ) )) + 29 (9 9 9 )

कोड ब्रेकडाउन:

गणित टूटना:

पायथ, एफ th (Ω Ω ) + 18 2 +183 (~ 256 27! )

पायथ, एफ 3 + + -1 + 256 2 (256 26 )

अजगर, एफ 3 (एफ 3 (141)), 512 बाइट्स

रूबी, शायद ~ एफ ω + ३५ ( ९ ९९ ९ )

अनुमानित गणित विवरण:

उदाहरण:

जी (1,1):

जी (1,2):

जी (1,3):

जी (2,5):

अजगर 3, एफ ω ω + ω * 9 (9 9 9 99 )

अजगर 3 , ~ च ε 0 (9 9 9 )

पायथन 3, 323 बाइट्स, जी 9 ई 9 (9)

व्याख्या

परिभाषा

परिभाषा बताई गई

Fgh सन्निकटन

रूबी, एफ ε 0 2 (5), 271 बाइट्स

स्पष्टीकरण:

उदाहरण

रूबी, च _{ψ ₀ (एक्स (Ω _{एम + एक्स (Ω _{एम + 1}^{Ω _{एम + 1}} )} )) + 29} (9 ^{9 ⁹} )

पायथ, एफ th _{(Ω ^Ω ) + ^{18 2} +183} (~ 256 ^27! )

पायथ, एफ _{3 + + _-1 +} 256 _² (256 ²⁶ )

अजगर, एफ ₃ (एफ ₃ (141)), 512 बाइट्स

रूबी, शायद ~ एफ _{ω + ३५} ( ^{९ ^९९}^९ )

अजगर 3, एफ _{ω ^ω + ω *} 9 (9 ^{9 ^{9 ⁹⁹}} )

अजगर 3 , ~ च _{ε ₀} (9 ^{9 ⁹} )

पायथन 3, 323 बाइट्स, जी 9 ^ई 9 (9)

रूबी, एफ_{ε ₀ 2} (5), 271 बाइट्स