आपका लक्ष्य एक प्रोग्राम लिखना है जो एक नंबर प्रिंट करता है। जितनी बड़ी संख्या, उतने अधिक अंक मिलेंगे। लेकिन सावधान रहना! स्कोरिंग फ़ंक्शन में कोड की लंबाई सीमित और भारी होती है। आपके मुद्रित नंबर को आपके समाधान के लिए आपके द्वारा उपयोग किए जाने वाले बाइट्स की संख्या के क्यूब से विभाजित किया जाएगा ।

तो, मान लीजिए कि आपने प्रिंट किया है 10000000और आपका कोड 100बाइट्स लंबा है। आपका अंतिम स्कोर किया जाएगा 10000000 / 100^3 = 10।

इस चुनौती को थोड़ा कठिन बनाने के लिए, अन्य नियमों का पालन करना है।

आप अपने कोड (0123456789) में अंकों का उपयोग नहीं कर सकते हैं;
आप गणितीय / भौतिक / आदि का उपयोग कर सकते हैं। स्थिरांक, लेकिन केवल यदि वे 10. से कम हैं (जैसे आप Pi ~ = 3.14 का उपयोग कर सकते हैं, लेकिन आप Avogadro स्थिरांक = 6e23 का उपयोग नहीं कर सकते हैं )
पुनरावृत्ति की अनुमति है लेकिन उत्पन्न संख्या को परिमित करने की आवश्यकता है (इसलिए अनंत को समाधान के रूप में स्वीकार नहीं किया जाता है। आपके कार्यक्रम को सही ढंग से समाप्त करने की आवश्यकता है, अबाधित समय और मेमोरी को संभालने और अनुरोधित आउटपुट उत्पन्न करने की आवश्यकता है);
आप संचालन का उपयोग नहीं कर सकते *(गुणा), /(विभाजित), ^(शक्ति) और न ही उन्हें इंगित करने का कोई अन्य तरीका (उदाहरण के 2 div 2लिए अनुमति नहीं है);
आपका कार्यक्रम एक से अधिक संख्याओं का उत्पादन कर सकता है, अगर आपको ऐसा करने की आवश्यकता है । केवल उच्चतम स्कोरिंग के लिए गणना करेगा;
हालांकि, आप तार को समाप्‍त कर सकते हैं: इसका अर्थ है कि आसन्न अंकों के किसी भी क्रम को एक ही संख्‍या माना जाएगा;
जैसे-जैसे आपका कोड चलाया जाएगा। इसका मतलब यह है कि एंड-यूज़र किसी भी कोड की पंक्ति को संपादित नहीं कर सकता है, न ही वह किसी नंबर या किसी अन्य चीज़ का इनपुट कर सकता है;
अधिकतम कोड की लंबाई 100 बाइट्स है।

लीडरबोर्ड

स्टीवन एच। , पायथ _φ एफ_{H (1,0,0) +7} (256²⁶ ) / 1000000^[1]
सिंपल ब्यूटीफुल आर्ट , रूबी _φ f Art _₁₂₁₍₍₎ (126)^[1]
पीटर टेलर , गोल्फस्क्रिप्ट _ε f₊_₀_{+ 1 + 1} (17) / 1000^[1]
रेस , GolfScript ≈ च_{ε ₀} (च_{ε ₀} (च_{ε ₀} (च_{ε ₀} (च_{ε ₀} (च_{ε ₀} (च_{ε ₀} (च_{ε ₀} (च_{ε ₀} (126)))))))))^[1]
_{^{सिंपल}}ब्यूटीफुल आर्ट , रूबी _ω f Art _¹⁹⁸³²₊₁ (1983)
eaglgenes101 , जूलिया _ω f₁₂₇₃ (127)
col6y , पायथन 3, ≈ (127 → 126 → ... → 2 → 1) / 99³ ^{[1] [3]}
Toeofdoom , हास्केल, ≈ एक ₂₀ (1) / 99³ ^[1]
फ्रैक्स्टिल , डीसी, d 15 d 100 15/100³ ^[3]
मैजेंटा , पायथन, on एसी (126,126) / 100³ ↑ 10129¹²⁴ 129
केंडल फ्रे , ECMAScript 6, ≈ 10^{3 ↑ ⁴ 3} /100³ ^[1]
Ilmari कारोनेन , GolfScript, ≈ 10 ↑³ 10³⁷⁷ /18³ ^[1]
ब्लैककैप , हास्केल, ↑↑ 10, 65503/100³
पुनरावर्ती , पायथन, ↑↑ 2 9511/95³ ↑↑ 10, 8.63297^{[1] [3]}
एनएम , हास्केल, ↑↑ 2 1007/100³ ↑↑ 10 97 4.63297^[1]
डेविड यॉ , सी, ≈ 10^{10 ^{4 × 10 ²²}} /83³ ≈ 10 ↑↑ ४.११,८२१^[2]
Primo , पर्ल, ≈ 10^{(१२७५०६८४१६१!) ^{5 × 2 ²⁷}} /100³ ≈ 10 ↑↑ ४.११,३६९
कला , सी, ≈ 10^{10 ^{2 × 10 ⁶}} /98³ ≈ 10 ↑↑ ३.८०,५८७
रॉबर्ट सोरली , x86, ø10^{2 ^{2 ¹⁹ +32}} / 100³ r 10 15 3.71585
Tobia , एपीएल, ≈ 10^{10 ³⁵³} /100³ ≈ 10 ↑↑ ३.४०,६१६
डैरेन स्टोन , सी, 10^{10 10 ^97.61735} / 98³ ↑↑ 10, 3.29875
ecksemmess , सी, ≈ 10^{2 ³²⁰} /100³ ≈ 10 ↑↑ ३.२९,७४९
एडम स्पीट , vb.net, ≈ 10^{5000 × (2 ⁶⁴ ) ⁴} /100³ ≈ 10 ↑↑ ३.२८,०३९
यहोशू , बैश, ≈ 10^{10 ¹⁵} /86³ ≈ 10 ↑↑ ३.०७,२८२

_{फुटनोट}

^{यदि ब्रह्माण्ड का प्रत्येक इलेक्ट्रॉन एक विचित्र था, और प्रत्येक सुपरपोज़िशन को जानकारी को संग्रहीत करने के लिए आसानी से उपयोग किया जा सकता है (जो, जब तक आपको वास्तव में यह जानने की आवश्यकता नहीं है कि क्या संग्रहीत किया जाना सैद्धांतिक रूप से संभव है), तो इस कार्यक्रम के लिए अधिक मेमोरी की आवश्यकता हो सकती है संभवतः मौजूद है, और इसलिए इसे चलाया नहीं जा सकता - अब, या भविष्य में किसी भी बोधगम्य बिंदु पर। यदि लेखक एक बार में author3 all 3.28 से बड़ा मान छापने का इरादा रखता है, तो यह शर्त लागू होती है।}
^{इस कार्यक्रम के लिए वर्तमान में मौजूद की तुलना में अधिक मेमोरी की आवश्यकता है, लेकिन इतना नहीं है कि यह सैद्धांतिक रूप से क्वैटर की एक बड़ी संख्या पर संग्रहीत नहीं किया जा सकता है, और इसलिए एक दिन एक कंप्यूटर मौजूद हो सकता है जो इस प्रोग्राम को चला सकता है।}
^{वर्तमान में उपलब्ध सभी दुभाषिए एक रनटाइम त्रुटि जारी करते हैं, या प्रोग्राम अन्यथा लेखक के रूप में निष्पादित करने में विफल रहता है।}
^{इस कार्यक्रम को चलाने से आपके सिस्टम को अपूरणीय क्षति होगी।}

@Primo को संपादित करें : मैंने स्कोरबोर्ड के एक हिस्से को नोटेशन की तुलना करने के लिए उम्मीद से आसान का उपयोग करते हुए दशमलव के साथ अगली उच्च शक्ति के लिए लघुगणक दूरी को चिह्नित करने के लिए अद्यतन किया है। उदाहरण 10 ↑↑ 2.5 = 10 के लिए ^{10 ^√10} । यदि मैंने उपयोगकर्ता के विश्लेषण को दोषपूर्ण माना है तो मैंने कुछ स्कोर भी बदल दिए हैं, इन में से किसी को भी विवाद के लिए स्वतंत्र महसूस करें।

इस संकेतन की व्याख्या:

अगर है 0 ≤ b < 1तो ।a↑↑b = a^b

अगर है b ≥ 1तो ।a↑↑b = a^a↑↑(b-1)

अगर है b < 0तो ।a↑↑b = log_a(a↑↑(b+1))

— Vereos
स्रोत

16

क्या किसी ने स्पष्ट रूप से "आधार 10" कहा है?

— केश्लाम

1

अगर यह 12e10(12 * 10 ^ 10) के रूप में बड़ी संख्या की गिनती करता है 12*10^10?

— hichris123

4

मुझे लगता है कि *, /, और ^ को मना करने के बजाय एक बेहतर बाधा है, केवल रैखिक संचालन, जैसे +, -, ++, -, + =, - =, आदि की अनुमति देने के लिए होगा , अन्यथा, कोडर लाभ उठा सकते हैं। नुथ के अप-एरो / एकरमन लाइब्रेरी कार्यों को यदि उनकी पसंद की भाषा में उपलब्ध कराया जाता है, जो धोखा देने जैसा लगता है।

— एंड्रयू चेयोंग

14

मैं अभी भी किसी को फुटनोट कमाने के लिए इंतजार कर रहा हूँ [४]।

— ब्रायन मिंटन

1

कहो, अगर मेरा प्रोग्राम प्रिंट करता है 500b, तो क्या यह अमान्य है? यही है, क्या हम सभी गैर-संख्यात्मक चीजों को प्रोग्राम प्रिंट को अनदेखा कर सकते हैं? और यदि हां, तो क्या कुछ इस तरह 50r7गिना जाएगा 507?

— ब्यूटीफुल आर्ट

20

GolfScript; स्कोर कम से कम f _{0_0 + ω + 1} (17) / 1000

इस प्रश्न के लिए कृमि उत्तर के जीवनकाल का उपयोग करने के लिए Res के सुझाव के बाद , मैं दो कार्यक्रमों को प्रस्तुत करता हूं जो हॉवर्ड के समाधान की व्युत्पत्ति पर बहुत सुधार करते हैं।

वे एक सामान्य उपसर्ग साझा करते हैं, फ़ंक्शन का नाम modulo:

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g

गणना करता है g(g(1)) = g(5)जहां g(x) = worm_lifetime(x, [x])के रूप में च मोटे तौर पर बढ़ता है _{ε ₀} (जो नोटों रेस "में समारोह है तेजी से बढ़ते पदानुक्रम है कि मोटे तौर पर बढ़ता है Goodstein समारोह के रूप में एक ही दर")।

विश्लेषण करने के लिए थोड़ा आसान (!) है

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{.{.{.{.{.{.{.{.{.{g}*}*}*}*}*}*}*}*}*}*

.{foo}*नक्शे xके लिए foo^x x।

,:z){[]+z\{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:g~g.{g}*

इस प्रकार देता है g^(g(5)) ( g(5) ); आगे के 8 स्तर पुनरावृत्ति तीर के समान हैं। सरल शब्दों में व्यक्त करने के लिए: यदि h_0 = gऔर h_{i+1} (x) = h_i^x (x)फिर हम गणना करते हैं h_10 (g(5))।

मुझे लगता है कि यह दूसरा कार्यक्रम लगभग निश्चित रूप से बेहतर स्कोर है। इस बार फ़ंक्शन gको सौंपा गया लेबल एक नई रेखा (सिक) है।

,:z){.[]+{\):i\.z={.z+.({<}+??\((\+.@<i*\+}{(;}if.}do;}:
~
{.['.{
}*'n/]*zip n*~}:^~^^^^^^^^^^^^^^^^

इस बार मैं ^एक अलग फ़ंक्शन के रूप में बेहतर उपयोग करता हूं ।

.['.{
}*'n/]*zip n*~

xस्टैक पर ले जाता है , और xउसके बाद एक स्ट्रिंग होती है जिसमें एक स्ट्रिंग होती है xऔर .{उसके gबाद xकॉपी होती है }*; यह तब स्ट्रिंग का मूल्यांकन करता है। चूंकि मेरे पास स्पेयर पात्रों को जलाने के लिए एक बेहतर जगह थी, हम इसके साथ शुरू करते हैं j_0 = g; अगर j_{i+1} (x) = j_i^x (x)तब ^गणना का पहला मूल्यांकन j_{g(5)} (g(5))(जो मुझे पूरा यकीन है कि पहले से ही पिछले कार्यक्रम को हरा देता है)। मैं तब ^16 और बार निष्पादित करता हूं ; तो अगर k_0 = g(5)और k_{i+1} = j_{k_i} (k_i)फिर यह गणना करता है k_17। मैं आभारी हूँ (फिर) कि अनुमान लगाने के लिए फिर से शुरू करने के लिए k_i>> एफ _{+_0 + 1 + 1} (i)।

— पीटर टेलर
स्रोत

अगर मैं गलत नहीं हूँ, तो आपके प्रोग्राम की संख्या (इसे कॉल करें n) n = f ^ 9 (g (3)) लिखा जा सकता है, जहाँ f (x) = g ^ (4x) (x), और g ( x) कृमि का जीवनकाल है [x]। अगर हम तेजी से बढ़ते पदानुक्रम में लगभग समान रूप से f_eps_0 के रूप में जी का इलाज करते हैं, तो मेरी "बैक-ऑफ-लिफाफा" गणना दर्शाती है कि f_ (eps_0 + 2) (9) <n <f_ (eps_0 + 2) (10) )। बेशक यह वर्तमान विजेता है - अब तक।

— रेस

@ मुझे लगता है कि यह काफी कम कर रहा है। .{foo}*नक्शे xके लिए foo^x (x)। यदि हम लेते हैं h_0 (x) = g^4 (x)और h_{i+1} (x) = h_i^x (x)उसके बाद गणना की जाती है h_9 (g(3))। आपका f(x) = g^(4x) (x) = h_0^x (x) = h_1 (x)।

— पीटर टेलर

(यह आपके मूल कार्यक्रम से संबंधित है - मैंने अभी देखा कि आपने कुछ संपादन किए हैं।) ओह्ह ... मुझे गलतफहमी हुई कि कैसे *काम करता है। यह कहना सुरक्षित है कि h_0 (x) = g ^ 4 (x) >> f_eps_0 (x); फलस्वरूप, संबंध h_ {i + 1} (x) = h_i ^ x (x) प्रभावी रूप से एक "त्वरित" तेजी से बढ़ने वाली पदानुक्रम को परिभाषित करता है जैसे कि h_i (x) >> f_ (eps_0 + i) (x)। यानी, गणना की गई संख्या h_9 (g (3)) निश्चित रूप से f_ (eps_0 + 9) (g (3)) से बहुत अधिक है। G (3) के लिए, मुझे लगता है कि मैं दिखा सकता हूं कि यह g_4 से बड़ा है, g_i अनुक्रम में चौथे नंबर का उपयोग ग्राहम की संख्या को परिभाषित करने के लिए किया जाता है (जो कि g_64 है)।

— रेस

@ एकड़, इसलिए j_i ~ f_{eps_0 + i}; क्या वह बनाता है k_i ~ f_{eps_0 + i omega + i^2}?

— पीटर टेलर

आपने जो लिखा है, उसे देखते हुए k_i ~ f_{ε_0 + ω}^i (k_0)। यहां तर्क दिया गया है: k_ {i + 1} = j_ {k_i} (k_i) = j_i (k_i) ~ f_ {ε_0 + ω} (k_i) ~ f_ {ε_0 + ω} ^ 2 (k_ {i-1}) ... ~ f_ {ε_0 + f} ^ {i + 1} (k_0), इसलिए k_i ~ f_ {f_0 + ω} ^ i (k_0)। पूरी तरह से तेजी से बढ़ते पदानुक्रम के संदर्भ में k_i पर बंधी एक बहुत ही रूढ़िवादी निचली सीमा है k_i >> f_{ε_0 + ω}^i (i) = f_{ε_0 + ω + 1} (i)।

— रेस

91

विंडोज 2000 - विंडोज 8 (3907172/23 32 = 321)

ध्यान दें: इस रन से पहले नहीं!

निम्न को बैच फ़ाइल में सहेजें और व्यवस्थापक के रूप में चलाएं।

CD|Format D:/FS:FAT/V/Q

आउटपुट जब 4TB ड्राइव पर बोल्ड में पहले मुद्रित संख्या के साथ चलता है।

ड्राइव D के लिए नई डिस्क डालें:
और तैयार होने पर ENTER दबाएँ ... फ़ाइल सिस्टम का प्रकार NTFS है।
नई फ़ाइल प्रणाली FAT है।
QuickFormatting 3907172M
FAT16 / 12 के लिए वॉल्यूम बहुत बड़ा है।

— हाथ-ए-खाना
स्रोत

19

सरासर असम्बद्ध प्रतिभा!

— वैलेस्टेस्ट

7

मुझे लगता है कि आप समाधान की लंबाई को कम करने वाले हैं जिसमें मुझे स्कोर के रूप में 321 मिलता हैYour printed number will be divided for the number of bytes you used for your solution^3.

— क्रंचर

1

77 upvotes, और फिर भी ... मैं ध्यान देता हूं कि स्कोर 321 है ...

— ब्यूटीफुल आर्ट

3

@SimplyBeautifulArt, यह स्कोर नहीं है, लेकिन यात्रा है। :

— हैंड-ई-फूड

4

जाहिर है, एक है कि कई एक अच्छा हंसी दिया। अब अगर केवल हम इसे लीडरबोर्ड तक पहुंचा सकते हैं ... किसी को "अपूरणीय क्षति" टैग अर्जित करने की आवश्यकता है;)

— बस सुंदर कला

87

GolfScript, स्कोर: जिस तरह से बहुत ज्यादा

ठीक है, हम गोल्फस्क्रिप्ट के कुछ वर्णों में कितनी बड़ी संख्या में प्रिंट कर सकते हैं?

आइए निम्नलिखित कोड से शुरू करें ( धन्यवाद, बेन! ), जो प्रिंट करता है 126:

'~'(

इसके बाद, इसे 126 बार दोहराते हैं, जिससे हमें लगभग 1.26126 × 10 ^{377 के} बराबर संख्या मिलती है :

'~'(.`*

(यह स्ट्रिंग पुनरावृत्ति है, गुणा नहीं, इसलिए यह नियमों के तहत ठीक होना चाहिए।)

अब, उस ३ --अंकों वाली संख्या को १० ३ ³⁷ : से थोड़ा अधिक दोहराएं :

'~'(.`*.~*

आप वास्तव में इस कार्यक्रम को कभी नहीं देखेंगे, क्योंकि यह लगभग 10 ³⁸⁰ ≈ 2 ¹¹⁴⁰ अंकों के साथ एक संख्या की गणना करने की कोशिश करता है । कोई भी कंप्यूटर कभी भी बड़ी संख्या में स्टोर नहीं किया जा सकता है, और न ही ऐसा कंप्यूटर कभी ज्ञात भौतिकी का उपयोग करके बनाया जा सकता है; नमूदार ब्रह्मांड में परमाणुओं की संख्या के बारे में 10 होने का अनुमान है ⁸⁰ है, तो भले ही हम किसी भी तरह इस्तेमाल कर सकते हैं ब्रह्मांड में सभी बात यह बड़ी संख्या स्टोर करने के लिए, हम अभी भी किसी भी तरह रटना होगा के बारे में 10 ³⁸⁰ /10 ⁸⁰ = प्रत्येक परमाणु में १० ^३०० अंक !

लेकिन मान लेते हैं कि हमारे पास ईश्वर के अपने गोल्फस्क्रिप्ट दुभाषिया हैं, जो इस तरह की गणना को चलाने में सक्षम हैं, और हम अभी भी संतुष्ट नहीं हैं। ठीक है, चलो फिर से करते हैं!

'~'(.`*.~*.~*

इस कार्यक्रम का आउटपुट, यदि यह पूरा हो सकता है, इसमें लगभग 10 ^{10 ³⁸³} अंक होंगे, और इसलिए लगभग 10 ^{10 ^{10 ^{383 के}}} बराबर होगा ।

लेकिन रुकें! उस कार्यक्रम की पुनरावृत्ति हो रही है ... हम इसे लूप में क्यों नहीं बदलते?

'~'(.`*.{.~*}*

यहाँ, लूप बॉडी लगभग 10 ³⁷⁷ बार चलती है , जिससे हमें एक सैद्धांतिक आउटपुट मिलता है, जिसमें लगभग 10 ^{10⋰ ^{10 ³⁷⁷}} अंक या तो होते हैं, जहाँ 10 की पुनरावृत्त शक्तियों का टॉवर लगभग 10 ³⁷⁷ कदम लंबा होता है। (वास्तव में, यह घोर कमतर है, क्योंकि मैं इस तथ्य की उपेक्षा कर रहा हूं कि बार-बार दोहराई जाने वाली संख्या भी हर बार लंबी हो जाती है, लेकिन अपेक्षाकृत यह एक मामूली बात है।)

लेकिन हम अभी तक नहीं किया है। चलो एक और लूप जोड़ें!

'~'(.`*.{.{.~*}*}*

यहां तक कि ठीक से लिखने के लिए ऐसी संख्याओं का एक अनुमान गूढ़ गणितीय संकेतन की आवश्यकता है। उदाहरण के लिए, नथ अप-एरो नोटेशन में , उपरोक्त प्रोग्राम के द्वारा संख्या (सैद्धांतिक रूप से) आउटपुट लगभग 10 , ³ 10 ³⁷⁷ होना चाहिए , दस की कुछ (या 10 ³⁷⁷ ) शक्तियां देना, मान लेना कि मैंने गणित सही किया था।

इस तरह की संख्याओं को "अविश्वसनीय रूप से विशाल" से परे, और "समझ से बाहर" के दायरे में मिलता है। जैसा कि, न केवल इस तरह की संख्याओं को लिखना या उनकी गिनती करना असंभव है (हम ऊपर दिए गए तीसरे उदाहरण में पहले से ही उस बिंदु से आगे निकल गए हैं), लेकिन उनका शाब्दिक गणित के बाहर कोई बोधगम्य उपयोग या अस्तित्व नहीं है। हम से, साबित कर सकते हैं गणित के सूक्तियों , कि इस तरह की संख्या में मौजूद हैं, जैसे हम GolfScript विनिर्देश कि उपरोक्त कार्यक्रम से साबित कर सकते हैं हैं , उन्हें गणना करता है, तो वास्तविकता और उपलब्ध भंडारण स्थान की सीमा हस्तक्षेप नहीं किया), लेकिन सचमुच वहाँ कुछ भी नहीं में भौतिक ब्रह्मांड जिसे हम किसी भी अर्थ में गिनने या मापने के लिए उपयोग कर सकते हैं।

फिर भी, गणितज्ञ कभी-कभी इससे भी बड़ी संख्या का उपयोग करते हैं । (सैद्धांतिक रूप से) संख्याओं की गणना जो बड़े से थोड़ा अधिक काम लेती है - केवल एक-एक करके अधिक छोरों को घोंसले में डालने के बजाय, हमें नेस्टेड छोरों की गहराई को दूर करने के लिए पुनरावृत्ति का उपयोग करने की आवश्यकता है । फिर भी, सिद्धांत रूप में, एक छोटे से गोल्फस्क्रिप्ट कार्यक्रम (100 बाइट्स के तहत अच्छी तरह से, मुझे उम्मीद है) लिखना संभव है (सैद्धांतिक रूप से) किसी भी संख्या को व्यक्त करने के लिए गणना करें, कहते हैं, कॉनवे जंजीर तीर संकेतन ; विवरण एक अभ्यास के रूप में छोड़ दिया जाता है। ;-)

— इल्मरी करोनें
स्रोत

9

"...No computer ever built could store a number that big...अगर मैं गलत हूं तो मुझे सुधारो, लेकिन मुझे नहीं लगता कि यह यहां लागू होता है। क्या यह केवल बार-बार "भंडारण" नहीं है और एक बार में 3 अंक (?) प्रिंट करना है, इसलिए अंतिम परिणाम को संग्रहीत करने की आवश्यकता नहीं है।

— केविन फेगन

12

@ केविनफ़ेगन: यह सच है - संख्या अविश्वसनीय रूप से दोहरावदार है, इसलिए इसे संपीड़ित करना आसान होगा। लेकिन फिर हम अब वास्तव में संख्या को स्वयं संग्रहीत नहीं कर रहे हैं, बल्कि कुछ सार सूत्र हैं जिनसे संख्या सैद्धांतिक रूप से गणना की जा सकती है; वास्तव में, इस तरह के सबसे कॉम्पैक्ट में से एक शायद गोल्फस्क्रिप्ट प्रोग्राम है जो इसे उत्पन्न करता है। इसके अलावा, एक बार जब हम अगले कार्यक्रम के लिए एक कदम आगे बढ़ जाते हैं, तो एक बार में अंकों को "प्रिंट" करना भी उन्हें छोड़ने से पहले अव्यावहारिक हो जाता है - ब्रह्मांड में शास्त्रीय गणना के कई चरणों को पूरा करने के लिए बस कोई ज्ञात तरीका नहीं है।

— इल्मरी करोनें

@ IlmariKaronen के गोल्फस्क्रिप्ट ने सिर्फ गोगोल को एक वेदगी दी!

— 23

5

कैसे के बारे में वास्तव में इस सीमा को आगे बढ़ाते हुए, देखें कि वास्तव में आप इसे 100 वर्णों के भीतर गोल्फस्क्रिप्ट में कितना बड़ा बना सकते हैं? जैसा कि यह खड़ा है, आपका परिणाम ग्राहम की संख्या (जो मेरे हास्केल समाधान "अनुमानित") से कम है, लेकिन जैसा कि आप कहते हैं कि गोल्फस्क्रिप्ट शायद आगे भी जा सकता है।

— बंद कर दिया

3

@leftractionabout: मैं गोल्फस्क्रिप्ट के 80 वर्णों में एक कॉनवे तीर संकेतन मूल्यांकनकर्ता लिखने में कामयाब रहा, हालांकि यह इस चुनौती की सभी आवश्यकताओं को पारित नहीं करता है (यह संख्यात्मक स्थिरांक और अंकगणितीय ऑपरेटरों का उपयोग करता है)। यह शायद सुधारा जा सकता है, लेकिन मुझे लगा कि मैं इसे एक नई चुनौती के रूप में ले सकता हूं।

— Ilmari कारोनेन

42

जावास्क्रिप्ट 44 चार्ट

यह थोड़ा धोखा लग सकता है:

alert((Math.PI+''+Math.E).replace(/\./g,""))

स्कोर = 31415926535897932718281828459045/44 ^ 3 88 3.688007904758867e + 26 ↑↑ 10 15 2.1536134004

— WallyWest
स्रोत

9

कोई नियम बिल्कुल भी नहीं झुका;) * 0123456789 का उपयोग नहीं कर सकते [जाँच] * किसी भी भाषा का उपयोग करें जिसमें अंक वैध वर्ण हैं; [जाँच] * आप गणित / भौतिक / आदि का उपयोग कर सकते हैं। स्थिरांक <१०। [जांच, 2 का इस्तेमाल किया] * पुनरावृत्ति की अनुमति है लेकिन उत्पन्न संख्या को परिमित करने की आवश्यकता है; [जांच, कोई पुनरावृत्ति नहीं] *, /, ^ का उपयोग नहीं कर सकते; [जाँच] आपका कार्यक्रम एक से अधिक संख्या का उत्पादन कर सकता है; [जांच] आप तारों को समतल कर सकते हैं; [जांच] आपका कोड जैसे-जैसे चलाया जाएगा; [जाँच] अधिकतम कोड लंबाई: 100 बाइट्स; [जांच] w / i 5 सेकंड को समाप्त करने की आवश्यकता है [जांच]

— WallyWest

पारित करके 2 चरित्रों की दाढ़ी "."के बजाय बदलने के लिए/\./g

— gengkev

1

@gengkev अफसोस की बात है, केवल .replace ("।", "") का उपयोग करके ही पहला हटा दिया जाता है। चरित्र; मैं है उपयोग करने के लिए वैश्विक सभी को बदलने के लिए बदलें। स्ट्रिंग से पात्र ...

— वैलेस्ट वेस्ट

आप m=Math,p=m.PI,e=m.E,s="",alert((p*p*p+s+e*e*e).replace(/\./g,s))इसके बजाय कर सकते हैं , आपका स्कोर तब 3100627668029981620085536923187664/63 ^ 3 = 1.240017943838551e + 28

— AMK

1

@ कॉरी एक के लिए, मैं एक निरंतर दोहराने नहीं जा रहा हूं, अन्यथा हर कोई इसका उपयोग कर रहा होगा ... दूसरा, मेरे पास वास्तव में एक दूसरा तर्क नहीं है ...

— वैलीवेस्ट

28

सी, स्कोर = 10 ^{10 ^97.61735} / 98 ³ ↑↑ 10 87 2.29874984

unsigned long a,b,c,d,e;main(){while(++a)while(++b)while(++c)while(++d)while(++e)printf("%lu",a);}

मैं स्कोरिंग में मदद की सराहना करता हूं। किसी भी अंतर्दृष्टि या सुधार की सराहना की जाती है। यहाँ मेरी विधि है:

n = १ से २ ^६४ -१ तक प्रत्येक संख्या का संघात, बार-बार (२ ^६४ -१) ^४ बार । सबसे पहले, यहां बताया गया है कि मैं कैसे (1) 2 से ⁶⁴ अंकों की संचयी संख्या का आकलन कर रहा हूं ( "बाद"): बाद के अनुक्रम में अंतिम संख्या 20 अंकों के साथ 2 ⁶⁴ -1 = है 18446744073709551615। इस प्रकार, किसी परिणाम में संख्या के 90% से अधिक (उन के साथ शुरू 1.. 919 अंक) है। चलो शेष 10% औसत 10 अंक मान लेते हैं। यह उससे बहुत अधिक होगा, लेकिन यह आसान गणित और कोई धोखा नहीं देने के लिए कम अनुमान है। उस परिणाम को दोहराया जाता है (2 ⁶⁴ -1) ⁴ बार, इसलिए लंबाईके एन हो जाएगा कम से कम (0.9 × (2 ⁶⁴ -1) × 19 + 0.1 × (2 ⁶⁴ -1) × 10) × (2 ⁶⁴ -1) ⁴ = ३.८६६१३ × 10 ⁹⁷ अंक। नीचे दी गई टिप्पणियों में, @primo ने n की लंबाई 4.1433x10 ⁹⁷ होने की पुष्टि की । तो n स्वयं उस शक्ति से 10 या 10 ^{10 ^{97.61735 होगा}} ।

एल = कोड के 98 चार्ट

स्कोर = एन / एल ³ = 10 ^{10 ^97.61735} / 98 ³

आवश्यकता: 64-बिट कंप्यूटर पर चलना चाहिए जहाँ sizeof(long) == 8। मैक और लिनक्स यह करेंगे।

— डैरेन स्टोन
स्रोत

2

सी में, 'z'निरंतर मूल्य है 122। सही?

— प्राइमो

1

मुझे लगता है कि printf("%d",n)संख्या बहुत बड़ी हो जाएगी। इसके अलावा, 64-बिट कंप्यूटर का मतलब 64-बिट लंबा नहीं है, उदाहरण के लिए विंडोज एलएलपी 64 मॉडल का उपयोग करें तो अभी भी 32 बिट्स है

— phuclv

3

इससे कोई फर्क नहीं पड़ता है। हस्ताक्षरित पूर्णांक अतिप्रवाह C में अपरिभाषित व्यवहार है, इसलिए यह अनुमान लगाना असंभव है कि आपके कोड के निष्पादित होने पर क्या होगा। यह वित्त की आवश्यकता का उल्लंघन कर सकता है।

— डेनिस

1

मुझे लगता है कि विश्लेषण थोड़ा बंद हो सकता है। का 0..2^64-1संघटन ठीक 357823770363079921190 अंक लंबा है। बार (2^64-1)^4बार 4.1433x10 ^ 97 है। उस पावर को 10 तक ले 10^10^97.61735जाएं is 10 to 3.29875। मुझे लगता है कि आप दस में से एक शक्ति आप की जरूरत नहीं है (ध्यान दें जहां का दावा कर रहे हैं 3.866×10^97बन गया 3.866^10^97।

— Primo

2

हाय @primo। इसे जांचने के लिए समय देने के लिए धन्यवाद। इसकी प्रशंसा करना। मैं देख रहा हूं कि तुम क्या कह रहे हो। मेरा अंतिम प्रतिपादक गलत है। इसके 2.0बजाय होना चाहिए 97। 10^10^10^2.00= 10^10^97.6। मैं अब अपने स्कोर में इसे प्रतिबिंबित करूंगा।

— डैरेन स्टोन

19

अजगर 3 - 99 वर्ण - (सबसे अधिक संभावना है) ग्राहम की संख्या से काफी बड़ा है

मैं एक और तेजी से बढ़ते समारोह के साथ आया हूं, जो एकरमन फ़ंक्शन के विस्तार पर आधारित है।

A=lambda a,b,*c:A(~-a,A(a,~-b,*c)if b else a,*c)if a else(A(b,*c)if c else-~b);A(*range(ord('~')))

http://fora.xkcd.com/viewtopic.php?f=17&t=31598 ने मुझे प्रेरित किया, लेकिन आपको मेरा नंबर समझने के लिए वहां देखने की जरूरत नहीं है।

यहाँ ackermann फ़ंक्शन का संशोधित संस्करण है जिसे मैं अपने विश्लेषण में उपयोग कर रहा हूँ:

A(b)=b+1
A(0,b,...)=A(b,...)
A(a,0,...)=A(a-1,1,...)
A(a,b,...)=A(a-1,A(a,b-1,...),...)

Aउपरोक्त कोड में मेरा कार्य तकनीकी रूप से समान नहीं है, लेकिन यह वास्तव में मजबूत है, ऊपर दिए गए तीसरे पंक्ति को बदलने के लिए निम्नलिखित कथन के साथ:

A(a,0,...)=A(a-1,a,...)

(ए को कम से कम 1 होना चाहिए, इसलिए इसे मजबूत होना होगा)

लेकिन अपने उद्देश्यों के लिए मैं यह मान लूंगा कि यह सरल के समान है, क्योंकि विश्लेषण पहले से ही एकरमैन के कार्य के लिए आंशिक रूप से किया जाता है, और इसलिए इस फ़ंक्शन के लिए जब इसमें दो तर्क होते हैं।

मेरा कार्य अंततः गारंटी देता है कि यह हमेशा रुकना बंद कर देगा क्योंकि यह हमेशा या तो: एक तर्क को हटाता है, पहले तर्क को घटाता है, या पहले तर्क को रखता है और दूसरे तर्क को घटाता है।

आकार का विश्लेषण

ग्राहम की संख्या, AFAIK, G(64)का उपयोग करते हुए प्रतिनिधित्व किया जा सकता है :

G(n) = g^n(4)
g(n) = 3 ↑^(n) 3

जहां एक ↑^(n)बी नथ का अप-ऐरो नोटेशन है।

भी:

A(a,b) = 2 ↑^(a-2) (b+3) - 3
A(a,0) ≈ 2 ↑^(a-2) 3
g(n) ≈ A(n+2,0) // although it will be somewhat smaller due to using 2 instead of 3. Using a number larger than 0 should resolve this.
g(n) ≈ A(n+2,100) // this should be good enough for my purposes.

g(g(n)) ≈ A(A(n+2,100),100)

A(1,a+1,100) ≈ A(0,A(1,a,100),100) = A(A(1,a,100),100)

g^k(n) ≈ A(A(A(A(...(A(n+2,100)+2)...,100)+2,100)+2,100)+2,100) // where there are k instances of A(_,100)
A(1,a,100) ≈ A(A(A(A(...(A(100+2),100)...,100),100),100),100)

g^k(100) ≈ A(1,k,100)
g^k(4) < A(1,k,100) // in general
g^64(4) < A(1,64,100)

उपरोक्त कार्यक्रम में व्यक्त संख्या है A(0,1,2,3,4,...,123,124,125)।

चूँकि g^64(4)ग्राहम का नंबर है, और मेरा गणित सही है, तो यह कम है A(1,64,100), मेरी संख्या ग्राहम की संख्या से काफी बड़ी है।

कृपया मेरे गणित में कोई भी गलतियाँ बताएं - हालाँकि यदि कोई नहीं हैं, तो इस प्रश्न का उत्तर देने के लिए यह अब तक की सबसे बड़ी संख्या है।

— सेल स्केग
स्रोत

4

अच्छा लग रहा है; स्पष्ट रूप से आपका "संशोधित एकरमैन" वास्तव में एक कॉनवे-चेन मूल्यांकनकर्ता है।

— को बंद कर दिया

1

@leftaroundabout काफी नहीं है, लेकिन मुझे लगता है कि इसमें उसी पुनरावर्ती ताकत के बारे में है। इसके अलावा - जीरो चेन में मान्य नहीं हैं, इसलिए आप स्कोर सूची में अपनी कॉनवे श्रृंखला से शून्य को छोड़ना चाहते हैं।

— सेल स्केग्ज

1

तुमने क्यों किया range(ord('~'))? क्या आप range(125)कम बाइट्स के लिए नहीं कर सकते हैं , जो आपको अधिक संख्या में निचोड़ने की अनुमति देगा range(A(9,9,9))?

— फलों का

1

@ चैलेंजर 5: नियम 1 कहता है "आप अपने कोड (0123456789) में अंकों का उपयोग नहीं कर सकते हैं"

— सेल स्केग्स

@CelSkeggs: ओह, मैं उस बारे में भूल गया।

— फलों को

18

पर्ल - स्कोर ↑↑ 10 - 4.1

$_=$^Fx($]<<-$]),/(?<R>(((((((((((((((((((.(?&R))*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

एक बार फिर से पर्ल के रेगेक्स इंजन को संयोजन के एक अकल्पनीय राशि के माध्यम से पीसने के लिए, इस बार एक पुनरावर्ती वंश का उपयोग कर।

आंतरिक अधिकांश अभिव्यक्ति में, हम .अनंत पुनरावृत्ति को रोकने के लिए नंगे होते हैं, और इस प्रकार पुनरावृत्ति के स्तर को स्ट्रिंग की लंबाई तक सीमित करते हैं।

हम इसका अंत करेंगे:

/((((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*/
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                                                           \
  (((((((((((((((((((.[ ])*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*
   ___________________/ \_____________________________________
  /                    .                                      \
                       .
                       .

... दोहराया 671088640 बार, की कुल के लिए 12750684161 nestings - जो काफी अच्छी तरह से की मेरे पिछले प्रयास डालता है 23 शर्म की बात है के लिए nestings। उल्लेखनीय रूप से, perl इस पर चोक नहीं होता (एक बार फिर, मेमोरी उपयोग लगभग 1.3GB पर स्थिर रहता है), हालांकि पहले प्रिंट स्टेटमेंट जारी होने से पहले इसमें काफी समय लगेगा।

नीचे दिए गए अपने पिछले विश्लेषण से यह निष्कर्ष निकाला जा सकता है कि अंक उत्पादन की संख्या के आदेश पर किया जाएगा (! +१२७५०६८४१६१) ^671,088,640 , जहां ! K है वाम क्रमगुणित की कश्मीर (देखें A003422 )। हम इसे (k-1) के रूप में अनुमानित कर सकते हैं ! , जो सख्ती से छोटा है, लेकिन परिमाण के उसी क्रम पर।

और अगर हम वुल्फरामलफा से पूछें :

... जो मुश्किल से मेरा स्कोर बदल देता है। मुझे यकीन है कि कम से कम 10 for 5 होगा । मुझे लगता है कि 10 and 4 और 10 a 4.1 के बीच का अंतर आपके विचार से बहुत बड़ा है।

पर्ल - स्कोर ↑↑ 10। 4

$_=$^Fx($]<<-$]),/((((((((((((((((((((((.*.*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*)*(??{print})/

हमारे लिए कुछ कॉम्बिनेटर करने के लिए पर्ल रेगेक्स इंजन का दुरुपयोग। एम्बेडेड कोडब्लॉक
(??{print})सीधे रिजेक्स में अपना परिणाम डालेगा। चूंकि $_पूरी तरह से 2एस (और printहमेशा का परिणाम है 1) से बना है, यह कभी भी मेल नहीं खा सकता है, और सभी संभावित संयोजनों के माध्यम से पर्ल कताई भेजता है, जिनमें से काफी कुछ है।

लगातार इस्तेमाल किया

$^F- अधिकतम सिस्टम फाइल हैंडल, आमतौर पर 2।
$]- समान संस्करण संख्या, के समान 5.016002।

$_फिर एक स्ट्रिंग है जिसमें अंक 671088640 बार 2दोहराया जाता है। मेमोरी का उपयोग लगभग 1.3GB पर स्थिर है, आउटपुट तुरंत शुरू होता है।

विश्लेषण

चलो पी _के (n) को परिभाषित करें कि प्रिंट स्टेटमेंट को कितनी बार निष्पादित किया गया है, जहां k नेस्टिंग की संख्या है, और n स्ट्रिंग की लंबाई प्लस एक है (सिर्फ इसलिए कि मुझे n + 1 लिखने का मन नहीं है । हर जगह)।

(.*.*)*
पी ₂ (एन) = [ 2, 8, 28, 96, 328, 1120, 3824, 13056, ... ]

$P_2(n)=\frac{1}{1\sqrt{2}}((2+\sqrt{2})^n-(2-\sqrt{2})^n)+\frac{0}{1}n$

((.*.*)*)*
पी ₃ (एन) = [ 3, 18, 123, 900, 6693, 49926, 372615, 278118, ... ]

$P_3(n)=\frac{2}{2\sqrt{12}}((4+\sqrt{12})^n-(4-\sqrt{12})^n)+\frac{2}{2}n$

(((.*.*)*)*)*
पी ₄ (एन) = [ 4, 56, 1044, 20272, 394940, 7696008, 149970676, 2922453344, ... ]

$P_4(n)=\frac{4}{3\sqrt{12}}((10+\sqrt{90})^n-(10-\sqrt{90})^n)+\frac{4}{3}n$

((((.*.*)*)*)*)*
पी ₅ (एन) = [ 5, 250, 16695, 1126580, 76039585, 5132387790, 346417023515, 23381856413800, ... ]

$P_5(n)=\frac{40}{22\sqrt{1122}}((34+\sqrt{1122})^n-(34-\sqrt{1122})^n)+\frac{30}{22}n$

(((((.*.*)*)*)*)*)*
पी ₆ (एन) = [ 6, 1452, 445698, 137050584, 42142941390, 12958920156996, ... ]

$P_6(n)=\frac{240}{102\sqrt{23562}}((154+\sqrt{23562})^n-(154-\sqrt{23562})^n)+\frac{132}{102}n$

((((((.*.*)*)*)*)*)*)*
पी ₇ (एन) = [ 7, 10094, 17634981, 30817120348, 53852913389555, ... ]

$P_7(n)=\frac{1120}{388\sqrt{763002}}((874+\sqrt{763002})^n-(874-\sqrt{763002})^n)+\frac{476}{388}n$

आदि में, सूत्र को निम्न के रूप में सामान्यीकृत किया जा सकता है:

$P_k(n)=\frac{C_k}{E_k\sqrt{B_k}}((A_k+\sqrt{B_k})^n-(A_k-\sqrt{B_k})^n)+\frac{D_k}{E_k}n$

कहाँ पे

$A_k=!k=\sum\limits_{n=0}^{k-1}{n!}$

यही है, k का वाम भाग , अर्थात सभी से कम का योग k (देखें A003422 )।

$B_k=A_k(A_k-1)$
$C_k=2^{k-2}{k\choose 4}$

मैं के लिए बंद रूपों निर्धारित करने में असमर्थ किया गया है डी _{कश्मीर} और ई _{कश्मीर} , लेकिन यह अगर हम चाहते हैं कि निरीक्षण बहुत ज्यादा बात नहीं करता है,

$\lim_{k\to\infty}\frac{C_k}{E_k}=\frac{k-1}{2}$ तथा $\lim_{k\to\infty}\frac{D_k}{E_k}=1$

23 घोंसलों के साथ , यह हमें एक अनुमानित स्कोर देता है:

$\frac{2}{9}10^{671088640\cdot(22\cdot(1177652997443428940314+\sqrt{1386866582387492850230084014226553545478282})^{671088640}+671088641)-6}$

यह वास्तव में लगभग सटीक होना चाहिए।

लेकिन इसे कल्पना में रखना आसान है, जिसे कल्पना करना थोड़ा आसान है, हम आंतरिक घातांक के आधार को अनुमानित कर सकते हैं:

$1177652997443428940314+\sqrt{1386866582387492850230084014226553545478282}\approx 10^{21.372}$

और फिर प्रतिपादक ही:

$(10^{21.372})^{671088640}\approx 10^{14342506414}$

और फिर वुल्फरामलफा से पूछें :

जिसे आप केवल 10 and 4 पर कॉल कर सकते हैं और उसके साथ हो सकते हैं।

— Primo
स्रोत

1

तो, यह केवल एक वैध समाधान होगा जब तक कि संस्करण संख्या 10 से कम न हो?

— मिस्टर लिस्टर

3

@MrLister हाँ। सौभाग्य से, 6 से अधिक कोई बड़ा संस्करण मौजूद नहीं है, और यहां तक कि इसे पूरी तरह से 'तैयार' नहीं माना जाता है, मूल रूप से 2000 में घोषित किए जाने के बावजूद।

— प्राइमो

@प्रिमो आपको एहसास है कि पर्ल के वर्जन नंबर> 10 में जाते ही आपको इस जवाब को संशोधित करना होगा? ;)

— वैलीवेस्ट

3

@ Eliseod'Annunzio अगर मैं उस दिन आने पर अभी भी जीवित हूँ - यदि कभी - मैं वापस आने और इसे ठीक करने का वादा करता हूँ।

— प्राइमो

2

एक चल समाधान जो 10। 4 से आगे निकल जाता है। ये काफ़ी प्रभावशाली है। वाहवाही!

— टोबिया

16

जावास्क्रिप्ट, 10 ↑↑↑↑ 210

100 वर्ण:

z=~~Math.E+'';o={get f(){for(i=z;i--;)z+=i}};o.f;for(i=z;i--;)for(j=z;j--;)for(k=z;k--;)o.f;alert(z)

अवलोकन के आधार पर कि अधिकतम रूप से पुनरावृत्ति fजाने का इष्टतम तरीका है, मैंने 13 कॉल को fनेस्टेड लूप कॉलिंग के 3 स्तरों के साथ बदल दिया f, zप्रत्येक बार (जबकि fबढ़ती रहती है z)।

मैंने अनुमान लगाया कि स्कोर कागज़ के एक टुकड़े पर विश्लेषणात्मक रूप से लिखा है- अगर कोई इसे देखने में दिलचस्पी रखता है तो मैं इसे टाइप करूँगा।

बेहतर स्कोर: 10 ↑↑ 13

जावास्क्रिप्ट, ठीक 100 वर्णों में, फिर:

z=~~Math.E+'';__defineGetter__('f',function(){for(i=z;i--;)z+=i});f;f;f;f;f;f;f;f;f;f;f;f;f;alert(z)

यह तीन तरीकों से मेरे मूल उत्तर को बेहतर बनाता है-

zवैश्विक दायरे में परिभाषित करना हमें o.zहर बार टाइप करने से बचाता है ।
वैश्विक स्कोप (विंडो) पर एक गेटर को परिभाषित करना और fइसके बजाय टाइप करना संभव है o.f।
अधिक पुनरावृत्तियों का fहोना एक बड़ी संख्या के साथ शुरू होने से अधिक मूल्य का है, इसलिए (Math.E+'').replace('.','')(= 2718281828459045, 27 वर्ण) के बजाय , ~~Math.E+''(= 2, 11 वर्ण) का उपयोग करना बेहतर है और fअधिक बार कॉल करने के लिए साल्व्ड वर्णों का उपयोग करें ।

चूंकि, नीचे और अधिक विश्लेषण किया गया है, प्रत्येक पुनरावृत्ति परिमाण M के क्रम में एक संख्या से उत्पन्न होता है, परिमाण 10 ^M के क्रम में एक बड़ी संख्या , यह कोड प्रत्येक पुनरावृत्ति के बाद उत्पन्न होता है

210 10 O (10 ² )
O (10 ^{10 ²} ) (O (10) 2)
O (10 ¹⁰ ) ² ) = O (10 ↑↑ 3)
O (10 ¹⁰ ) ³ ) = O (10 ↑↑ 4)
O (10 10 ^{10 4} ) = O (10 ↑↑ 5)
O (10 10 ^{10 5} ) = O (10 ↑↑ 6)
O (10 10 ^{10 6} ) = O (10 ↑↑ 7)
O (10 10 ^{10 7} ) = O (10 ↑↑ 8)
O (10 10 ^{10 8} ) = O (10 ↑↑ 9)
O (10 ¹⁰ ) ⁹ ) = O (10 ↑↑ 10)
O (10 ¹⁰ ) ¹⁰ ) = O (10 10 11)
O (10 10 ^{10 11} ) = O (10 ↑↑ 12)
O (10 ¹⁰ ) ¹² ) = O (10 10 13)

स्कोर: ↑↑ ^{10 10 ^{10 ^{10 ^{10 ¹⁶}}}} ↑↑ 10 66 6.080669764

जावास्क्रिप्ट, ठीक 100 वर्णों में:

o={'z':(Math.E+'').replace('.',''),get f(){i=o.z;while(i--){o.z+=i}}};o.f;o.f;o.f;o.f;o.f;alert(o.z)

प्रत्येक o.fलूप को लूप करता है, कुल 5 लूप के लिए। केवल पहले पुनरावृत्ति के बाद, स्कोर पहले से ही 10 ^{42381398144233621} से अधिक है । दूसरे पुनरावृत्ति द्वारा, गणितज्ञ परिणाम में अंकों की संख्या की गणना करने में असमर्थ था ।

यहाँ कोड का एक walkthrough है:

में इस

दशमलव बिंदु को हटाकर 2718281828459045 से शुरू करें Math.E।

Iteration 1

संख्याओं के घटते क्रम को समाप्‍त करें,

2718281828459045
2718281828459044
2718281828459043
...
3
2
1
0

एक नया (विशाल) संख्या बनाने के लिए,

271828182845904527182818284590442718281828459043 ... +९८७६५४३२१०।

इस संख्या में कितने अंक हैं? खैर, यह है

1718281828459046 16-अंकीय संख्या
900000000000000 15-अंकीय संख्या
90000000000000 14-अंकीय संख्या,
9000000000000 13-अंकीय संख्या
...
900 3 अंकों की संख्या
90 2 अंकों की संख्या
10 1-अंकीय संख्या

गणित में,

In[1]:= 1718281828459046*16+Sum[9*10^i*(i+1),{i,-1,14}]+1
Out[1]= 42381398144233626

दूसरे शब्दों में, यह 2.72⋅10 ^{42381398144233625 है} ।

मेरा स्कोर बनाने के बाद, केवल पहली पुनरावृत्ति के बाद, 2.72 ^{410 42381398144233619} ।

Iteration 2

लेकिन यह केवल शुरुआत है। अब, चरणों को दोहराएँ, विशाल संख्या के साथ शुरू ! यही है, संख्याओं के घटते क्रम को समेटना,

271828182845904527182818284590442718281828459043 ... +९८७६५४३२१०
271828182845904527182818284590442718281828459043 ... +९८७६५४३२०९
271828182845904527182818284590442718281828459043 ... +९८७६५४३२०८
...
3
2
1
0

तो, मेरा नया स्कोर क्या है, गणितज्ञ?

In[2]:= 1.718281828459046*10^42381398144233624*42381398144233625 + Sum[9*10^i*(i + 1), {i, -1, 42381398144233623}] + 1

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

During evaluation of In[2]:= General::ovfl: Overflow occurred in computation. >>

Out[2]= Overflow[]

Iteration 3

दोहराएँ।

गर्भाधान ४

दोहराएँ।

Iteration 5

दोहराएँ।

विश्लेषणात्मक स्कोर

पहले पुनरावृत्ति में, हमने अंकों की संख्या की गणना 2718281828459045 पर शुरू होने वाले घटते क्रम के अंकों में की, जिसमें अंकों की संख्या गिनकर

1718281828459046 16-अंकीय संख्या
900000000000000 15-अंकीय संख्या
90000000000000 14-अंकीय संख्या,
9000000000000 13-अंकीय संख्या
...
900 3 अंकों की संख्या
90 2 अंकों की संख्या
10 1-अंकीय संख्या

इस राशि को सूत्र द्वारा दर्शाया जा सकता है,

यहाँ छवि विवरण दर्ज करें

जहाँ Z प्रारंभिक संख्या को दर्शाता है ( उदाहरण 2718281828459045) और O _Z , परिमाण के अपने क्रम को दर्शाता है ( जैसे 15, Z eg 10 ^{15 के} बाद से )। परिमित रकम के लिए समकक्षों का उपयोग करते हुए , उपरोक्त को स्पष्ट रूप से व्यक्त किया जा सकता है

यहाँ छवि विवरण दर्ज करें

जो, अगर हम 9 9 10 लेते हैं, तो और भी कम कर देता है

यहाँ छवि विवरण दर्ज करें

और, अंत में, शब्दों का विस्तार और उन्हें परिमाण के घटते क्रम से, हम प्राप्त करते हैं

यहाँ छवि विवरण दर्ज करें

अब, जब से हम केवल परिणाम के परिमाण के क्रम में रुचि रखते हैं, चलो Z को " O _Z के परिमाण के क्रम में एक संख्या" के साथ प्रतिस्थापित करते हैं , अर्थात 10 ^{O _Z} -

यहाँ छवि विवरण दर्ज करें

अंत में, दूसरी और तीसरी शर्तें रद्द हो जाती हैं, और अंतिम दो शब्द गिराए जा सकते हैं (उनका आकार तुच्छ है), हमें छोड़कर

यहाँ छवि विवरण दर्ज करें

जिसमें से पहला कार्यकाल जीत जाता है।

पुनर्स्थापित किया गया, Mf की परिमाण के क्रम में एक संख्या लेता है और M (10 ^M ) के परिमाण के क्रम में लगभग एक संख्या उत्पन्न करता है ।

पहली पुनरावृत्ति को आसानी से हाथ से चेक किया जा सकता है। 2718281828459045 15 की परिमाण के क्रम में एक संख्या है - इसलिए f15 (10 ¹⁵ ) ¹⁶ 10 ¹⁶ के परिमाण के क्रम में एक संख्या का उत्पादन करना चाहिए । दरअसल, पहले से उत्पादित संख्या, २. ^the२ 4१० ^{४२३98१३} ९ ²³ ९ ^{१४३२३६२५२५} है, १० ^४२३ ,१३ ^९ 4 ^{९ ⁴} ९ ^{४२३३५२ is} १० ^१०^{^{१६ है}} ।

यह देखते हुए कि एम एम (10 ^एम ) में महत्वपूर्ण कारक नहीं है , प्रत्येक पुनरावृत्ति के परिणाम की परिमाण का क्रम, फिर, टेट्रेशन का एक सरल पैटर्न निम्नानुसार है:

१० ^१६
१० ^{१० ^१६}
१० ^{१० ^{१० ^१६}}
१० ^{१० ^{१० ^{१० ^१६}}}
१० ^{१० ^{१० ^{१० ^{१० ^१६}}}}

लाटेक्स के स्रोत

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\sum_{k=0}^{\mathcal{O}_Z-1}{(9\cdot10^k(k+1))}+1

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\frac{10-\mathcal{O}_Z10^{\mathcal{O}_Z}+(\mathcal{O}_Z-1)10^{\mathcal{O}_Z+1}}{9}+10^{\mathcal{O}_Z}

(Z-10^{\mathcal{O}_Z}+1)(\mathcal{O}_Z+1)+\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+1

Z\mathcal{O}_Z+Z-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}+10^{\mathcal{O}_Z}-10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}+\mathcal{O}_Z+2

\mathcal{O}_Z10^{\mathcal{O}_Z}-\mathcal{O}_Z10^{\mathcal{O}_Z-1}

— एंड्रयू च्योंग
स्रोत

आपके स्कोर के बारे में मेरी राय उस अवलोकन पर आधारित है जो fकुछ ऐसा करता है जैसे संख्या zको अपनी शक्ति के रूप में लेना। तो ऐसा कुछ है ↑↑↑। बेशक स्कोर नहीं है 2↑↑↑2 , क्षमा करें ... अधिक पसंद है, 2↑↑↑5+1ऐसा लगता है। क्या आप सहमत होंगे, क्या मुझे लीडरबोर्ड में रखना चाहिए?

— को बंद कर दिया

@leftaroundabout - इसे फिर से देखने के लिए धन्यवाद। यदि आपका सुझाव सही लगता है या नहीं यह कहने के लिए मैं अप-एरो नोटेशन के साथ पर्याप्त सहज महसूस नहीं करता, लेकिन मैंने अपने स्कोर के परिमाण के क्रम की गणना की (देखें संपादित करें) यदि आप उस के साथ लीडरबोर्ड को अपडेट करना चाहते हैं।

— एंड्रयू चेयोंग

अति उत्कृष्ट! मैं ऊपर-तीर के साथ बिल्कुल भी दृढ़ नहीं हूं। तो वास्तव में आपके पास "केवल" शक्ति का एक टॉवर है; मुझे डर है कि आप रैंकिंग में दो स्थान नीचे रख देंगे। परिणाम का ठीक से विश्लेषण करने के लिए यश; मेरे अनुमानों में शायद अभी तक अधिक खामियां हैं, लेकिन मुझे लगा कि किसी को कम से कम उत्तरों में कुछ आदेश प्राप्त करने की कोशिश करनी चाहिए।

— बंद हो गया

1

आपका स्कोर गलत है। जब भी आप एक लूप शुरू i=o.z;while(i--)...करते हैं तो आप लूप के o.zसमय को अंजाम नहीं दे रहे हैं , क्योंकि लूप एक पूर्णांक चर पर आधारित o.zहोता है और इसमें आपके इंटरप्रेटर के शब्द आकार के आधार पर सबसे बड़ा प्रतिनिधित्व योग्य पूर्णांक से बड़ा स्ट्रिंग होता है। अपने लाभ के लिए यह सोचते हुए कि आपका दुभाषिया ऐसे स्ट्रिंग को इंट में परिवर्तित करने पर रोक नहीं लगाएगा, iहर बार अपने सबसे बड़े प्रतिनिधित्व योग्य पूर्णांक मूल्य के साथ शुरू करेगा, मान लीजिए कि यह 2 ^ 63 है, और वर्तमान मूल्य के साथ नहीं o.z।

— तोबिया

2

@ acheong87 अपने आप को दूर न करें, आपको अपने स्कोर को फिर से बदलना होगा, लूप चर को 2 ^ 63 या इस तरह से कैप करना होगा। पुनश्च: अपने विश्लेषणात्मक स्कोर को यहां पोस्ट करें, यह बहुत शिक्षाप्रद है!

— टोबिया

14

एपीएल, 10 ↑↑ 3.4

यहाँ मेरा संशोधित प्रयास है:

{⍞←⎕D}⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⍣n⊢n←⍎⎕D

100 चार / बाइट * कार्यक्रम, वर्तमान हार्डवेयर पर चल रहा है (स्मृति की एक नगण्य मात्रा और नियमित 32-बिट इंट चर) का उपयोग करता है, हालांकि इसे पूरा करने में बहुत लंबा समय लगेगा।

आप वास्तव में इसे एपीएल दुभाषिया पर चला सकते हैं और यह अंकों की छपाई शुरू कर देगा। यदि पूरा करने की अनुमति दी जाती है, तो उसने 10 × 123456789 ⁴⁴ अंकों के साथ एक नंबर प्रिंट किया होगा ।

इसलिए स्कोर 10 ^{10 × 123456789 ⁴⁴} /100 ³ ≈ 10 ^{10 ³⁵³} ≈ 10 ↑↑ ३.४,०६,१६१

व्याख्या

⎕D के बराबर एक पूर्वनिर्धारित स्थिरांक है '0123456789'
n←⍎⎕Dउस स्ट्रिंग द्वारा दर्शाई गई संख्या को परिभाषित करना n : 123456789 (जो <2 ^{31 है} और इसलिए इसे लूप कंट्रोल लूप के रूप में इस्तेमाल किया जा सकता है)
{⍞←⎕D} एक नई रूपरेखा के बिना, मानक आउटपुट के लिए 10 अंक प्रिंट करेगा
{⍞←⎕D}⍣nयह n बार करेगा ( ⍣"पावर ऑपरेटर" है: यह न तो *, /, और न ही ^ है, क्योंकि यह गणित का संचालन नहीं है, यह एक तरह का लूप है)
{⍞←n}⍣n⍣nपिछले ऑपरेशन दोहराया जाएगा n बार है, इसलिए 10 अंक मुद्रण एन ² बार
{⍞←n}⍣n⍣n⍣nइसे n ³ बार करेंगे
मैं ⍣nवहां 44 फिट कर सकता था, इसलिए यह स्ट्रिंग में n ⁴⁴ गुना प्रिंट करता है '0123456789'।

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
^{*: एपीएल अपने स्वयं के (विरासत) सिंगल-बाइट चारसेट में लिखा जा सकता है जो एपीएल प्रतीकों को ऊपरी 128 बाइट मानों में मैप करता है। इसलिए, स्कोरिंग के उद्देश्य से, N वर्णों का एक प्रोग्राम जो केवल ASCII वर्ण और APL प्रतीकों का उपयोग करता है, को N बाइट्स माना जा सकता है।}

— Tobia
स्रोत

आपके प्रिंट किए गए नंबर को आपके समाधान के लिए उपयोग किए जाने वाले बाइट्स की संख्या के लिए विभाजित किया जाएगा ^ 3। , आप अभी 100 से विभाजित कर रहे हैं।

— toastyMallows

2

@ToastyMallows - 100 cubedमेरे लिए (100 ^ 3) जैसा दिखता है।

— केविन फेगन

1

मुझे पता है लेकिन यह बाइट्स है, अक्षर नहीं।

— toastyMallows

1

@ToastyMallows जवाब पर अंतिम नोट्स पढ़ें।

— बस सुंदर कला

बदलें {⍞←⎕D}करने के लिए ⍞←जो आप तीन बाइट्स है कि आप एक अधिक जोड़ने के लिए उपयोग कर सकते हैं की बचत होती है ⍣nऔर बनाने ⊢n←⍎⎕Dमें ⌽⍕n←⍎⎕Dएक 80 गुना वृद्धि के लिए। यदि आप इसके साथ चलने की अनुमति देते हैं, ⎕PP←17तो ×⍨इसके बजाय उपयोग किए जाने ⌽⍕वाले अंकों की संख्या लगभग दोगुनी हो जाती है।

— आदम

12

हास्केल, स्कोर: (2 ^{2 ^{2 ⁶⁵⁵³⁶}} -3) / 1000000 ↑↑ 2 ≈ 7 ↑↑ 10 77 4.6329710779

o=round$sin pi
i=succ o
q=i+i+i+i
m!n|m==o=n+i
 |n==o=(m-i)!i
 |True=(m-i)!(m!(n-i))
main=print$q!q

यह कार्यक्रम शुद्ध हास्केल कोड के 100 बाइट्स है। यह चौथे एकरमैन नंबर को प्रिंट करेगा, अंततः सभी उपलब्ध ऊर्जा, पदार्थ और ब्रह्मांड के समय का उपभोग करेगा और इस प्रक्रिया में (इस तरह 5 सेकंड की नरम सीमा से थोड़ा अधिक) होगा।

— एनएम
स्रोत

o=length[]आप !qअंत में एक अतिरिक्त हो जाता है और आप उस के शीर्ष पर एक बाइट बचाता है।

— खुल्द्रेसथ ना'बरिया

9

पायथन, 2/11/830584 ↑↑ 10 9 8.632971 (नथ अप एरो नोटेशन)

print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))

संभवतः किसी भी कंप्यूटर के पास इसे सफलतापूर्वक चलाने के लिए पर्याप्त मेमोरी नहीं है, लेकिन यह वास्तव में प्रोग्राम की गलती नहीं है। न्यूनतम सिस्टम आवश्यकताओं को संतुष्ट करने के साथ, यह काम करता है।

हाँ, यह बूलियन मूल्यों पर थोड़ा बदलाव कर रहा है। इस संदर्भ में Trueमजबूर हो जाता 1है। अजगर की मनमानी लंबाई पूर्णांक है।

— पुनरावर्ती
स्रोत

आपका कोड नहीं चलता है। केवल print True<<(True<<(True<<(True<<True<<True)))करता है, और वह 19k स्ट्रिंग आउटपुट करता है।

— गाबे

उस न्यूनतम सिस्टम आवश्यकताएँ क्या हैं?

— डेन्यूबियन सेलर

8

क्या आप इसे परिभाषित करने t=Trueऔर फिर उपयोग करने के tबाद छोटा नहीं कर सकते थे ?

— बॉब

1

बेहतर अभी तक, बस एक लूप बनाओ जो आपके लिए ये घोंसले बनाता है।

— बस सुंदर कला

यह मेरे लिए विफल है:

$python -c 'print True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<(True<<True<<True)))))))))' Traceback (most recent call last):   File "<string>", line 1, in <module> OverflowError: long int too large to convert to int

— ब्रायन मिंटन

8

गोल्फस्क्रिप्ट 3.673e + 374

'~'(.`*

मुझे लगता है *कि अनुमति दी जाती है क्योंकि यह स्ट्रिंग पुनरावृत्ति को इंगित करता है, गुणा नहीं।

स्पष्टीकरण: '~'(स्टैक पर 126 ("~" का ASCII मूल्य) छोड़ देगा। फिर संख्या को कॉपी करें, इसे एक स्ट्रिंग में परिवर्तित करें, और 126 बार स्ट्रिंग पुनरावृत्ति करें। यह देता है 126126126126...जो लगभग है 1.26 e+377। समाधान 7 अक्षरों का है, इसलिए 7^3लगभग एक अंक के लिए विभाजित करें3.673e+374

— बेन रीच
स्रोत

7

रूबी, संभावित रूप से अनंत, 54 वर्ण

x='a'.ord
x+=x while x.times.map(&:rand).uniq[x/x]
p x

x को 97 के लिए आरंभीकृत किया गया है। फिर हम निम्नलिखित प्रक्रिया को पुन: व्यवस्थित करते हैं: x को 0 और 1 के बीच यादृच्छिक संख्या में उत्पन्न करते हैं। यदि वे सभी समान हैं, तो x को समाप्त करें और प्रिंट करें। अन्यथा, डबल एक्स और दोहराएं। चूंकि रूबी के यादृच्छिक संख्याओं में सटीकता के 17 अंक हैं, इसलिए किसी भी चरण में समाप्त होने की संभावना 1 (10e17) ^ x में हैं। इसलिए n चरणों के भीतर समाप्त होने की संभावना इसलिए x = 1 से n (1 / 10e17) ^ (2 ^ n) के लिए योग है, जो 1 / 10e34 में परिवर्तित होती है। इसका मतलब यह है कि किसी भी संख्या के लिए, चाहे कितना भी बड़ा हो, यह बहुत अधिक संभावना नहीं है कि यह कार्यक्रम कम संख्या में आउटपुट करता है।

अब, निश्चित रूप से, दार्शनिक प्रश्न यह है कि क्या एक कार्यक्रम जिसमें 10 एन में 1 से कम है ^ किसी भी एन के लिए चरण एन द्वारा समाप्त करने का मौका कभी भी समाप्त करने के लिए कहा जा सकता है। यदि हम न केवल अनंत समय और शक्ति को मानते हैं, लेकिन यह कि कार्यक्रम को एक ऐसी गति से चलाने की क्षमता दी जाती है, जो उस दर से अधिक हो जिस पर समाप्त होने की संभावना कम हो जाती है, तो हम कर सकते हैं, मुझे विश्वास है, वास्तव में संभावना समय से समाप्त करना t मनमाने ढंग से 1 के करीब।

— histocrat
स्रोत

3

यह संख्या जनरेटर पर निर्भर करता है जो अधिकांश भाषाओं में समान संख्या में 97 गुना उत्पन्न करने में सक्षम नहीं है

— शाफ़्ट फ्रीक

1

अच्छी बात है, इसलिए लगातार तेजी से बढ़ती गणना शक्ति को संभालने के अलावा, मुझे यादृच्छिकता का एक आदर्श स्रोत और एक रूबी कार्यान्वयन का उपयोग करने की भी आवश्यकता है।

— हिस्टोक्रेट

7

GolfScript, ≈ च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (126)))))))))

यह बेशर्मी से @Hardard द्वारा दूसरे उत्तर से अनुकूलित है , और @Peter टेलर द्वारा सुझावों को शामिल करता है।

[[[[[[[[[,:o;'~'(]{o:?~%{(.{[(]{:^o='oo',$o+o=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:f~]f]f]f]f]f]f]f]f

GolfScript की मेरी समझ सीमित है, लेकिन मेरा मानना है कि ऊपर *और ^ऑपरेटर ओपी द्वारा मना किए गए अंकगणितीय ऑपरेटर नहीं हैं ।

(मैं खुशी से इसे हटा दूंगा यदि @ हॉवर्ड अपना खुद का संस्करण प्रस्तुत करना चाहता है, जो निस्संदेह इस एक से बेहतर होगा।)

इस कार्यक्रम के एक नंबर च लगभग है कि गणना करता है _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (126)))))) ))) - च की एक नौ गुना यात्रा _{ε ₀} जहां च - _{ε ₀} में समारोह है तेजी से बढ़ते पदानुक्रम है कि मोटे तौर पर बढ़ता है Goodstein समारोह के रूप में एक ही दर। (च _{ε _०)}इतनी तेजी से बढ़ता है फ्राइडमैन के एन की वृद्धि दर (के) समारोह और कश्मीर गुना कोनवे की श्रृंखलित कि तीर भी तुलना में लगभग नगण्य हैं बस एक ही गैर दोहराया च को _{ε ₀} ।)

— रेस
स्रोत

'',:o;'oo',:t;बस मान प्रदान करती है 0करने के लिए oऔर 2करने के लिए t; अगर यह सिर्फ अंकों की कमी के आसपास काम करने के लिए है ,:o)):t;, तो इसे भारी रूप से संक्षिप्त किया जा सकता है , सिवाय इसके कि tपहली जगह में हटाने का कोई कारण नहीं है क्योंकि आप आगे के 3 वर्णों expr:t;{...}:f;[[[t]f]f]fको [[[expr:t]{...}:f~]f]fबचाने के रूप में लिख सकते हैं ।

— पीटर टेलर

अभी भी पॉप करने की कोई आवश्यकता नहीं है o: मुझे पूरा यकीन है कि आप [0 126]fएक से अधिक बड़े होंगे [126]fताकि आप एक चार को बचा सकें और आउटपुट को टक्कर दे सकें। हालाँकि आप वहाँ एक खाली स्ट्रिंग छोड़ रहे हैं, जो शायद चीजों को तोड़ देती है: यह शुरू करने के लिए बेहतर हो सकता है[[,:o'~'=]

— पीटर टेलर

ओह, और [अनावश्यक हैं क्योंकि आपके पास स्टैक पर कुछ और नहीं है।

— पीटर टेलर

हा ... इन जवाबों को स्क्रॉल करते हुए, और फिर मैं इसे देखता हूं ... और फिर मैं स्वीकृत उत्तर पर ध्यान देता हूं ... एचएम ......

— बस सुंदर कला

@SimplyBeautifulArt मुझे यकीन नहीं है कि आपका क्या मतलब है, लेकिन स्वीकृत उत्तर इस एक की तुलना में बहुत बड़ी संख्या की गणना करता है (दोनों के रूप में दावा किया गया है)।

— रेस

7

डीसी, 100 अक्षर

[lnA A-=ilbA A-=jlaSalbB A--SbLndB A--SnSnlhxlhx]sh[LaLnLb1+sbq]si[LbLnLasbq]sjFsaFsbFFFFFFsnlhxclbp

पर्याप्त समय और स्मृति को देखते हुए, यह लगभग 15 I had 15. एक संख्या की गणना करेगा। मैंने मूल रूप से हाइपरोपरेशन फ़ंक्शन को लागू किया था , लेकिन इस चुनौती के लिए बहुत अधिक वर्णों की आवश्यकता थी, इसलिए मैंने n = 2, b = 0और n >= 3, b = 0शर्तों को हटा दिया, स्थिति को मोड़ n = 1, b = 0दिया n >= 1, b = 0।

यहां उपयोग किए जाने वाले एकमात्र अंकगणित ऑपरेटर जोड़ और घटाव हैं।

संपादित करें: जैसा कि टिप्पणियों में वादा किया गया है, यहां यह कोड क्या है, इसका टूटना है:

[            # start "hyperoperation" macro
lnA A-=i     # if n == 0 call macro i
lbA A-=j     # if b == 0 call macro j
laSa         # push a onto a's stack
lbB A--Sb    # push b-1 onto b's stack
LndB A--SnSn # replace the top value on n with n-1, then push n onto n's stack
lhxlhx       # call macro h twice
]sh          # store this macro in h

[            # start "increment" macro (called when n=0, the operation beneath addition)
LaLnLb       # pop a, b, and n
F+sb         # replace the top value on b with b+15
q            # return
]si          # store this macro in i

[            # start "base case" macro (called when n>0 and b=0)
LbLnLa       # pop b, n, and a
sb           # replace the top value on b with a
q            # return
]sj          # store this macro in j

Fsa          # store F (15) in a
Fsb          # store F (15) in b
FFFFFFsn     # store FFFFFF "base 10" (150000+15000+1500+150+15=1666665) in n
lhx          # load and call macro h
lbp          # load and print b

जैसा कि उल्लेख किया गया है, यह हाइपरोपरेशन फ़ंक्शन से विचलन करता है जिसमें आधार मामलों को गुणा और उच्चतर के लिए आधार मामले के साथ बदल दिया जाता है। इस कोड के रूप में यद्यपि व्यवहार करती है a*0 = a^0 = a↑0 = a↑↑0 ... = a, गणितीय सही के बजाय a*0 = 0और a^0 = a↑0 = a↑↑0 ... = 1। नतीजतन, यह उन मूल्यों की गणना करता है जो उन्हें होने की तुलना में थोड़ा अधिक हैं, लेकिन यह कोई बड़ी बात नहीं है क्योंकि हम बड़ी संख्या के लिए लक्ष्य बना रहे हैं। :)

संपादित करें: मैंने अभी देखा कि एक अंक दुर्घटना में कोड में फिसल गया, मैक्रो में जो वेतन वृद्धि करता है n=0। मैंने इसे 'एफ' (15) के साथ बदलकर हटा दिया है, जिसमें 15. से प्रत्येक वेतन वृद्धि ऑपरेशन को स्केल करने का दुष्प्रभाव है। मुझे यकीन नहीं है कि यह अंतिम परिणाम को कितना प्रभावित करता है, लेकिन यह शायद अब बहुत बड़ा है।

— Fraxtil
स्रोत

मुझे नहीं पता कि यह कोड क्या करता है ... केवल यह मान सकता है कि यह सही है। शायद आप थोड़ा समझा सकते हैं?

— को बंद कर दिया

जब मैं आज रात को समय दूंगा, तब मैं टुकड़ा द्वारा कोड टुकड़ा समझाऊंगा।

— फ्रैक्स्टिल

खैर, मैं उस स्पष्टीकरण पर आया, लेकिन मैंने इसे अभी जोड़ दिया है। आशा है कि इससे चीजें साफ होंगी।

— फ्रैक्स्टिल

dc-1.06.95-2 तुरंत समाप्त हो जाता है, जिसमें कुछ भी नहीं मुद्रित होता है।

— प्रिमो

1

मैं इसे किसी भी मौजूदा मशीन पर काम करने की उम्मीद नहीं करूंगा, क्योंकि यह उस मूल्य का परिमाण होगा जो इसे उत्पन्न करने की कोशिश करेगा। मेरे पास dc का एक ही संस्करण है और यह कुछ ही सेकंड के बाद segfaults करता है। मैं मान रहा हूं कि "सैद्धांतिक रूप से सही" उत्तर यहां दिए गए हैं, क्योंकि संसाधन की खपत का कोई मापदंड नहीं है।

— ९

6

रनटाइम पर कोई अधिक सीमा नहीं? ठीक है फिर।

क्या कार्यक्रम को आधुनिक कंप्यूटर पर चलाने योग्य बनाने की आवश्यकता है?

64-बिट संकलन का उपयोग करके दोनों समाधान, ताकि long64-बिट पूर्णांक हो।

सी: अधिक से अधिक 10 ^{(2 ⁶⁴ -1) ^{2 ⁶⁴}} है, जो खुद से अधिक 10 ^{10 ^{355393490465494856447}} ≈ 10 ↑↑ ४.१,१८,२०,७४४

long z;void f(long n){long i=z;while(--i){if(n)f(n+~z);printf("%lu",~z);}}main(){f(~z);}

88 अक्षर।

इन सूत्रों को आसान बनाने के लिए, मैं उपयोग करूँगा t = 2^64-1 = 18446744073709551615।

mainके fपैरामीटर के साथ कॉल करेगा t, जो लूप tसमय, प्रत्येक बार मान को प्रिंट करने t, और के fपैरामीटर के साथ कॉल करने के लिए होगा t-1।

कुल अंक छपे 20 * t:।

उनमें से प्रत्येक कॉल विल के समय के fपैरामीटर के साथ t-1करेगा t, मान को प्रिंट करेगा t, और के पैरामीटर के साथ कॉलिंग करेगा t-2।

कुल अंक छपे: 20 * (t + t*t)

मैंने 3-बिट पूर्णांक (मैंने सेट किया i = 8था और मुख्य कॉल किया था f(7)) के बराबर का उपयोग करके इस कार्यक्रम की कोशिश की । यह 6725600 बार प्रिंट स्टेटमेंट से टकराया। 7^8 + 7^7 + 7^6 + 7^5 + 7^4 + 7^3 + 7^2 + 7इसलिए यह काम करता है , मेरा मानना है कि यह पूर्ण कार्यक्रम के लिए अंतिम गणना है:

कुल अंक छपे: 20 * (t + t*t + t^3 + ... + t^(t-1) + t^t + t^(2^64))

मुझे यकीन नहीं है कि कैसे गणना करें (2 ⁶⁴ -1) ^{2 ⁶⁴} । यह योग (2 ⁶⁴ ) ^{2 ⁶⁴} से छोटा है , और मुझे यह गणना करने के लिए दो की शक्ति की आवश्यकता है। इसलिए, मैं गणना करूँगा (2 ⁶⁴ ) ^{2 ⁶⁴ -1} । यह वास्तविक परिणाम से छोटा है, लेकिन चूंकि यह दो की शक्ति है, इसलिए मैं इसे अन्य परिणामों की तुलना में 10 की शक्ति में बदल सकता हूं।

क्या किसी को पता है कि उस प्रदर्शन को कैसे करना है, या कैसे परिवर्तित करना है (2 ⁶⁴ -1) ^{2 ⁶⁴} से 10 ^एन ?

20 * 2 ^ 64 ^ (2 ^ 64-1)
20 * 2 ^ 64 ^ 18446744073709551615
20 * 2 ^ (64 * 18446744073709551615)
20 * 2 ^ 1180591620717411303360
10 * 2 ^ 1180591620717411303361
10 की शक्तियों के लिए घातांक का आधार स्विच करने के लिए 10 के लॉग बेस 2 से उस घातांक को विभाजित करें।
1180591620717411303361 / 3.321928094887362347870319429489390175864831393024580612054756 = 
355393490465494856446
10 * 10 ^ 355393490465494856446
10 ^ 355393490465494856447

लेकिन याद रखें, कि अंकों की संख्या मुद्रित है। पूर्णांक का मान उस शक्ति से 10 बढ़ा है, इसलिए 10 ^ 10 ^ 355393490465494856447

इस कार्यक्रम में 2 ^ 64 की स्टैक गहराई होगी। यह लूप काउंटर को स्टोर करने के लिए 2 ^ 72 बाइट्स है। यह लूप काउंटर के 4 बिलियन टेराबाइट्स है। अन्य चीजों का उल्लेख नहीं करने के लिए जो 2 ^ 64 पुनरावृत्ति के स्तर के लिए स्टैक पर जाएंगे।

संपादित करें: टाइपोस की एक जोड़ी को ठीक किया, और लॉग 2 (10) के लिए अधिक सटीक मूल्य का उपयोग किया।

संपादित करें 2: एक सेकंड रुको, मुझे एक लूप मिला है जो प्रिंटफ के बाहर है। चलो ठीक करते हैं। जोड़ा गया इनिशियलाइज़िंग i।

संपादन 3: इसे डांग करें, मैंने पिछले संपादन पर गणित को खराब कर दिया। फिक्स्ड।

यह एक आधुनिक कंप्यूटर पर चलेगा, हालांकि यह जल्द ही समाप्त नहीं होगा।

C: 10 ^ 10 ^ 136 ↑↑ 10 9 3.329100567

#define w(q) while(++q)
long a,b,c,d,e,f,g,x;main(){w(a)w(b)w(c)w(d)w(e)w(f)w(g)printf("%lu",~x);}

98 वर्ण।

यह प्रत्येक पुनरावृत्ति के लिए एक बार शून्य, 2 ^ 64-1 के बिटवाइज़-इनवर्स को प्रिंट करेगा। 2 ^ 64-1 एक 20 अंकों की संख्या है।

अंकों की संख्या = 20 * (2^64-1)^7= 14536774485912137805470195290264863598250876154813037507443413987271378962275710279090680680672487878758878188188204182042857551818005751818755184752182

कार्यक्रम की लंबाई को 100 वर्णों तक पहुंचाना, स्कोर = मुद्रित संख्या / 1,000,000

स्कोर = 10 ^ 14536774485912137805470195290264863598250876154813037505074434139872713789622757102732707806724876857587878188204182041828285284497494494497494

— डेविड याव
स्रोत

शायद। %u64-बिट संकलन के साथ भी 32-बिट संख्या मुद्रित कर रहा था, इसलिए मैंने सिर्फ ll32-बिट संकलक में लिखने की आदत से बाहर किया ।

— डेविड याव

मुझे लगता है कि के लिए %lluहोगा long long, और के %luलिए सही होगा long।

— टोमलॉजिक

फिक्स्ड। आदत का बल: %uहमेशा 32-बिट है, %lluहमेशा 64-बिट है, चाहे 32 या 64 बिट के रूप में संकलित किया जाए। हालाँकि, यहाँ समाधान की आवश्यकता है कि long64-बिट हो, इसलिए आप सही हैं, %luपर्याप्त है।

— डेविड याव

स्टैक पर आपके चर को 0. आरंभिक होने की गारंटी नहीं है। दूसरे कार्यक्रम में, बस उन्हें किसी भी फ़ंक्शन के बाहर रखें। पहले एक में, आपको आरंभ करना होगा i।

— कला

इसके अलावा, लंबे समय तक अतिप्रवाह अपरिभाषित व्यवहार है और कई आधुनिक संकलक इसे दूर कर देंगे यदि वे इसका पता लगाते हैं, तो आप शायद बिना लंबे समय के उपयोग करना चाहते हैं।

— आर्ट

5

आर - कोड के ४ ९ ४१ अक्षर, 4.03624169270483442 * 10 ^ 5928 ↑↑ 10 13 2.576691348

set.seed(T)
cat(abs(.Random.seed),sep="")

बाहर प्रिंट होगा [यहाँ शुरू करने का पुनरुत्पादन]:

403624169270483442010614603558397222347416148937479386587122217348........

— lebatsnok
स्रोत

2

मुझे नहीं लगता कि आपको पोस्ट में नंबर शामिल करने की आवश्यकता है। यह मोबाइल पर भी बहुत जगह लेता है।

— पूरी तरह से

@totallyhuman मैं सहमत हूं, शायद पहले 100 अंक, अधिकतम

— tuskiomi

@totallyhuman ठीक है धन्यवाद किया :)

— lebatsnok

catएक अजीब समारोह है जिसमें पहला तर्क है ...। तो पहले नामित तर्क से पहले सब कुछ ...(और होगा cat'एड), जिसके कारण sepइसका नाम होना चाहिए - अन्यथा कोई इसे छोटा नहीं कर सकता हैcat(abs(.Random.seed),,"")

— lebatsnok

5

ECMAScript 6 - 10 ^ 3 AS 3/884736

(3 64 3 G है (1) जहां G (64) ग्राहम का नंबर है)

u=-~[v=+[]+[]]+[];v+=e=v+v+v;D=x=>x.substr(u);K=(n,b)=>b[u]?n?K(D(n),K(n,D(b))):b+b+b:e;u+K(v,e)

आउटपुट: 10 ^ 3। 3

संकेत:

Gवह फ़ंक्शन है जहां G (64) ग्राहम का नंबर है। इनपुट एक पूर्णांक है। आउटपुट एक unary string है जिसके साथ लिखा गया है 0. संक्षिप्तता के लिए निकाला गया।

Kनथ-अप-एरो फ़ंक्शन एक Kn ⁿ b है जहाँ a निहित है। 3. इनपुट n, एक unary string, और b, एक unary string है। आउटपुट एक unary string है।

u "1" है।

v "0000", या G (0) है

e "000" है।

— केंडल फ्रे
स्रोत

Maximum code length is 100 bytes;अन्यथा यह अपराजेय के पास है

— Cruncher

@ क्रंचर आह, मुझे याद आया कि

— केंडल फ्रे

आह, मुझे तुमसे नफरत है अब। हर बार मैं ग्राहम की संख्या के आकार को देखने की कोशिश करता हूं, जिससे मेरा सिर दर्द होता है।

— क्रंचर

भी, ग्राहम की संख्या एक स्थिर> 10 के रूप में नहीं गिना जाता है?

— सेराकफाल्कन

1

अब यह निर्धारित करने के लिए कि क्या खदान इल्मरी की है।

— केंडल फ्रे

5

सी

(डैरेन स्टोन से माफी के साथ)

long n,o,p,q,r;main(){while(--n){while(--o){while(--p){while(--q){while(--r){putchar('z'-'A');}}}}}}

n = 2 ^ 64 अंकों की संख्या (9 ...)

l = कोड के 100 वर्ण

स्कोर 20 1e + 21359870359209100823950217061695521146027045223566527699470416078222197257806405500229686936570 ≈ 10 ↑↑ 3.2974890744

]

ध्यान दें कि मैं इस जवाब के लिए निर्दयता से लताड़ा जा सकता हूं, लेकिन विरोध नहीं कर सका। मैं स्पष्ट कारणों के लिए स्टेक्सएक्सचेंज पर मेरे जैसा अभिनय करने की सलाह नहीं देता। :-P

संपादित करें: ऐसा कुछ करने के लिए प्रलोभन का विरोध करना और भी कठिन होगा

long n;main(){putchar('z'-'A');putchar('e');putchar('+');while(--n){putchar('z'-'A');}

... लेकिन मुझे लगता है कि एक इरादा लेकिन अनिर्दिष्ट नियम यह था कि अंक बनाने की पूरी दौड़ संख्या को मुद्रित करना होगा।

— ecksemmess
स्रोत

1

#DEFINE C जबकि (- long n, o, p, q, r, s, t; main () {Cn) {Co) {Cp) {Cq) {Cr {Cs {Ct) {putchar ('z' -अ'');}}}}}}}}

— रोबू

@RobAu तुम एक प्रतिभाशाली हो! इसका उत्तर बनाओ। मुझे यकीन है कि यह विजेता होगा। मुझे लगता है कि आप एक जोड़े को भूल गए ), लेकिन यह ठीक है, क्योंकि आप अभी केवल 96 वर्णों पर हैं।

— एंड्रयू लार्सन

उन सभी के लिए, जिन्हें कटाक्ष नहीं मिला: एक बेहतर समाधान के लिए codegolf.stackexchange.com/a/18060/7021 देखें ;)

— RobAu

5

नई रूबी: स्कोर ~ एफ _{ω ¹²⁶² +1} (126 ² 2 ¹²⁶ )

जहां f _α (n) तेजी से बढ़ता पदानुक्रम है।

n=?~.ord;H=->a{b,*c=a;eval"b ?H[b==$.?c:[b==~$.?n:b-(b<=>$.)]*n+c]:p(n+=n);"*n};eval"H[~n];".*n*n<<n

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

*nसिर्फ स्ट्रिंग और सरणी गुणन हैं, इसलिए वे ठीक होना चाहिए।

अघोषित कोड:

n = 126
H =-> a {
    b, *c = a
    n.times{
        case b
        when nil
            puts(n += n)
        when 0
            H[c]
        when -1
            H[[n]*n+c]
        else
            H[[b.-b<=>0]*n+c]
        end
    }
}
(n*n<<n).times{H[~n]}

जहां b.-b<=>0एक पूर्णांक देता है जो की तुलना में 1करीब 0है b।

स्पष्टीकरण:

यह nहर कॉल की शुरुआत में प्रिंट करता है H।

H[[]]युगल n( nबार), अर्थात n = n<<n।

H[[0,a,b,c,...,z]]कॉल H[[a,b,c,...,z]]( nबार)।

H[[k+1,a,b,c,...,z]]कॉल H[[k]*n+[a,b,c,...,z]]( nबार), जहां [k]*n = [k,k,...,k]।

H[[-1,a,b,c,...,z]]कॉल H[[n]*n+[a,b,c,...,z]]( nबार)।

H[[-(k+1),a,b,c,...,z]]कॉल H[[-k]*n+[a,b,c,...,z]]( nबार)।

H[k] = H[[k]]।

मेरा कार्यक्रम आरंभ करता है n = 126, फिर H[-n-1]126 ² 2 ¹²⁶ बार कॉल करता है।

उदाहरण:

H[[0]]कॉल करेगा H[[]]जो लागू होता है n = n<<n( nसमय)।

H[[0,0]]H[[0]]( nबार) को बुलाएगा ।

H[[1]]H[[0]*n]( nबार) को बुलाएगा ।

H[[-1]]H[[n]*n]( nबार) को बुलाएगा ।

H[[-1,-1]]H[[n]*n+[-1]]( nबार) को बुलाएगा ।

H[[-3]]H[[-2]*n]( nबार) को बुलाएगा ।

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

अन्य ठंडी चीजों के लिए संशोधन देखें ।

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

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— हाइपरएन्यूट्रीनो

यह वास्तव में 103 बाइट्स है, आपके पास एक अनुगामी न्यूलाइन है जो मुझे लगता है।

— R

@ रिकर मेरा मानना है कि आपने यहां से कॉपी और पेस्ट किया है। ध्यान दें कि दूसरी पंक्ति पर एक अप्राप्य चरित्र होना चाहिए, इसलिए 104 बाइट्स।

— बस सुंदर कला

@SimplyBeautifulArt आह, ठीक है। मुझे लगा कि मैंने किरदार की नकल की है। माफ़ करना।

— at

@ रिकर नाह, इसकी वजह से भी स्टेक्सएक्सचेंज ने मुझे हर जगह अदृश्य पात्रों को छिपाने की अनुमति नहीं दी।

— बस सुंदर कला

4

हास्केल - एकरमैन फ़ंक्शन ने अपने परिणाम पर 20 बार - 99 वर्णों पर लागू किया

यह सबसे अच्छा हैस्केल समाधान है जो मैं एकरमैन फ़ंक्शन के आधार पर ले सकता हूं - आप एनएम के समाधान के लिए कुछ समानताएं देख सकते हैं, i = राउंड $ लॉग पाई वहां से प्रेरित था और शेष संयोग है: डी

i=round$log pi
n?m|m<i=n+i|n<i=i?(m-i)|True=(n-i)?m?(m-i)
a n=n?n
b=a.a.a.a
main=print$b$b$b$b$b$i

यह एक समय में एक बार शुरू होने वाले क्रम को 20 बार चलाता है, एक क्रम से

1,
3,
61,
एक (61,61),
a ((61,61), a (61,61)) --- हम इसे ₂ (61) या ₄ (1) कहेंगे ---
एक ₃ (61)
...
एक ₁₈ (61), या ₂₀ (1)। मुझे लगता है कि यह लगभग जी ₁₈ (नीचे देखें) है।

अनुमान के अनुसार, विकिपीडिया कहता है:

a (m, n) = 2) ^m-2 (n + 3) - 3

इससे हम a3 (1) = (a (61,61) = 2 64 ⁵⁹ 64 + 3 देख सकते हैं, जो स्पष्ट रूप से g1 = 3 3 ⁴ 3 से अधिक है , जब तक कि प्रारंभ में 3 मेरे विचार से अधिक महत्वपूर्ण नहीं है। उसके बाद, प्रत्येक स्तर निम्नलिखित (एक में नगण्य स्थिरांक को त्यागकर करता _n ):

g _n = 3 ^_n^{g _n-1} 3
a _n ~ = 2 ↑ ^{a _n-1} (a _-1 )

यदि ये लगभग बराबर हैं, तो एक ₂₀ (1) ~ = जी ₁₈ । _N , ( _n-1 ) में अंतिम शब्द 3 से अधिक है, इसलिए यह संभावित रूप से जी ₁₈ से अधिक है । मैं देखूंगा कि क्या मैं यह पता लगा सकता हूं कि क्या यह एक भी पुनरावृत्ति को बढ़ावा देगा और वापस रिपोर्ट करेगा।

— Toeofdoom
स्रोत

आपका विश्लेषण सही है और जी <उप> 18 </ उप> एक अच्छा सन्निकटन है।

— बस सुंदर कला

length"a"एक युगल बाइट्स बचाता है और आपको एक और की अनुमति देता है.a

— खुल्द्रेसथ ना'बरिया

4

x86 मशीन कोड - 100 बाइट्स (MSDOS .com फ़ाइल के रूप में इकट्ठे)

नोट: नियमों को थोड़ा मोड़ सकते हैं

यह कार्यक्रम 2 ^{(65536 * 8 + 32)} नाइन का उत्पादन करेगा जो स्कोर को डाल देगा (10 ^{2 ⁵²⁴³²⁰} -1 / 1000000)

एक काउंटर के रूप में यह कार्यक्रम पूरे स्टैक (64kiB) के साथ-साथ दो 16bit रजिस्टरों का उपयोग करता है

कोडित कोड:

8A3E61018CD289166101892663018ED331E4BB3A01438A2627
018827A0300130E4FEC4FEC4FEC410E4FEC400E431C95139CC
75FB31D231C931DBCD3F4175F94275F45941750839D4740D59
4174F85131C939D475F9EBDD8B266301A161018ED0C3535858

सभा:

ORG 0x100

SECTION .TEXT
            mov bh, [b_ss]
            mov dx, ss
            mov [b_ss], dx
            mov [b_sp], sp
            mov ss, bx
            xor sp, sp
            mov bx, inthackdst
            inc bx
            mov ah, [inthacksrc]
            mov [bx], ah
            mov al, [nine]
            xor ah, ah
            inc ah
            inc ah
            inc ah
inthacksrc: adc ah, ah
            inc ah
            add ah, ah
            xor cx, cx
fillstack:  push cx
nine:       cmp sp, cx
            jnz fillstack
regloop:    xor dx, dx
dxloop:     xor cx, cx
cxloop:     xor bx, bx
inthackdst: int '?'
            inc cx
            jnz cxloop
            inc dx
            jnz dxloop
            pop cx
            inc cx
            jnz restack
popmore:    cmp sp, dx
            jz end
            pop cx
            inc cx
            jz popmore
restack:    push cx
            xor cx, cx
            cmp sp, dx
            jnz restack
            jmp regloop
end:        mov sp, [b_sp]
            mov ax, [b_ss]
            mov ss, ax
            ret

b_ss:       dw 'SX'
b_sp:       db 'X'

— रॉबर्ट सोरली
स्रोत

आपने स्पष्ट रूप से यह कभी नहीं चलाया। यह अपने कोड को ओवरराइट करता है और क्रैश करता है।

— जोशुआ

4

सी

फ़ाइल का आकार 45 बाइट्स है।

कार्यक्रम है:

main(){long d='~~~~~~~~';while(--d)printf("%ld",d);}

और उत्पादित संख्या 10 ^ (10 ^ (10 ^ 1.305451600608433)) से बड़ी है।

जिस फ़ाइल को मैंने एसटीडी पर पुनर्निर्देशित किया है वह वर्तमान में 16 जीबी से अधिक है, और अभी भी बढ़ रहा है।

यदि मेरे पास एक बेहतर कंप्यूटर है तो कार्यक्रम उचित समय में समाप्त हो जाएगा।

मेरा स्कोर डबल सटीक फ़्लोटिंग पॉइंट के साथ अविश्वसनीय है।

— iWiggins
स्रोत

4

GNU बैश, 10 ^ 40964096 B / 80 ^ 3 ^ 10 ≈ 2.072820169

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C count=$C$C|tr \\$((C-C)) $SHLVL'

किसी भी उचित प्रणाली पर C = 4096। SHLVL एक छोटा सा धनात्मक पूर्णांक है (आमतौर पर या तो 1 या 2 निर्भर करता है कि क्या / बिन / श को बैश है या नहीं)।

केवल 64 बिट यूनिक्स:

स्कोर: ~ 10 ^ (40964096409640964096 * 40964096409640964096) / 88 ^ 3

C=$(stat -c %s /) sh -c 'dd if=/dev/zero bs=$C$C$C$C$C count=$C$C$C$C$C|tr \\$((C-C)) $SHLVL'

— यहोशू
स्रोत

SHLVL, सबबेस के रूप में बैश का स्तर है:bash -c 'bash -c "echo \$SHLVL"'

— एफ।

stat --printfकाम नहीं करते। कोशिशstat -c %s

— एफ। होरी

@ F.Hauri: --printf मेरे लिए काम करता है, लेकिन ऐसा इसलिए करता है ताकि कुछ बाइट्स शेव की जा सकें। धन्यवाद।

— जोशुआ

4

सी, 10 ^ 10 ^ 2485766 ↑↑ 10 5 3.805871804

unsigned a['~'<<'\v'],l='~'<<'\v',i,z;main(){while(*a<~z)for(i=l;printf("%u",~z),i--&&!++a[i];);}

हम 258048 अहस्ताक्षरित पूर्णांकों की एक सरणी बनाते हैं। यह लंबे समय तक अहस्ताक्षरित नहीं हो सका क्योंकि इससे कार्यक्रम बहुत लंबा हो गया। वे अहस्ताक्षरित हैं क्योंकि मैं अपरिभाषित व्यवहार का उपयोग नहीं करना चाहता, यह कोड उचित सी है (मुख्य () से वापसी की कमी के अलावा) और किसी भी सामान्य मशीन को संकलित और चलाएगा, हालांकि यह लंबे समय तक चलता रहेगा । यह आकार सबसे बड़ा है जिसे हम गैर-अस्की पात्रों का उपयोग किए बिना कानूनी रूप से व्यक्त कर सकते हैं।

हम अंतिम तत्व से शुरू होने वाले सरणी के माध्यम से लूप करते हैं। हम 2^32-1तत्व को बढ़ाते हैं, तत्व को बढ़ाते हैं और लूप को छोड़ते हैं यदि तत्व 0. से लिपटा नहीं है। इस तरह हम लूप के (2^32 - 1)^254048 = 2^8257536समय को बढ़ाएंगे, हर बार 10 अंकों को प्रिंट करेंगे ।

यहां उदाहरण कोड है जो सिद्धांत को अधिक सीमित डेटा श्रेणी में दिखाता है:

#include <stdio.h>
unsigned int a[3],l=3,i,f;

int
main(int argc, char *argc){
        while (*a<4) {
        for (i = l; i-- && (a[i] = (a[i] + 1) % 5) == 0;);
            for (f = 0; f < l; f++)
                printf("%lu ", a[f]);
            printf("\n");
        }
}

परिणाम लगभग 10 ^ 10 ^ 2485766 एक लाख से विभाजित है जो अभी भी लगभग 10 ^ 10 ^ 2485766 है।

— कला
स्रोत

बेस्ट सी कार्यान्वयन, अब तक। 5 चर का उपयोग क्यों करें , जब आप 258048 की सरणी का उपयोग कर सकते हैं ?

— प्राइमो

4

पॉवर्सशेल (2.53e107976 / 72 6. = 6.78e107970 (10 01 1.701857171)

इसे चलाने में 5 सेकंड से अधिक समय लगता है।

-join(-split(gci \ -r -EA:SilentlyContinue|select Length))-replace"[^\d]"

यह आपके वर्तमान ड्राइव पर हर फ़ाइल की बाइट लंबाई को पुनः प्राप्त और संक्षिप्त करता है। रेगेक्स किसी भी गैर-अंक वर्णों को स्ट्रिप्स करता है।

— हाथ-ए-खाना
स्रोत

नियम 1 कहता है कि कोई अंक अनुमति नहीं है, आपके पास 0वहां है।

— काइल कानोस

धिक्कार है, मैं भी करता हूं। वहां मेरा कैरेक्टर काउंट होता है।

— हाथ-ई-फूड

आप -ea(+'')आकार को कम करने के लिए उपयोग कर सकते हैं ( ''एक संख्या में परिवर्तित किया जाता है 0, जो कि एनम मूल्य है SilentlyContinue)। आप \Dप्रतिस्थापन रेगेक्स के लिए उपयोग कर सकते हैं जो कि जैसा है वैसा ही है [^\d]। और आप केवल उपयोग कर सकते %{$_.Length}हैं select Lengthजिसके बजाय कॉलम हेडर से छुटकारा मिलता है। और फिर आप छुटकारा पा सकते हैं -splitऔर -replaceसाथ ही, आपको छोड़ कर -join(gci \ -ea(+'')-r|%{$_.Length})जिसके साथ 37 अक्षर छोटे हैं (मैंने भी मापदंडों को फिर से व्यवस्थित किया है क्योंकि कोष्ठक की आवश्यकता वैसे भी होती है +'')।

— जॉय

4

पायथन 3, स्कोर = ack (126,126) / 100 ^ 3

g=len('"');i=ord('~');f=lambda m,n:(f(m-g,f(m,n-g))if n else f(m-g,g))if m else n+g
print(f(i,i))

F फंक्शन एकरमैन फंक्शन है, जिसे करने के लिए मेरे पास पर्याप्त जगह है।

संपादित करें: पहले "और n + 1", जो चुनौती के नियमों का उल्लंघन करने के लिए था- यश टू सिंपली ब्यूटीफुल आर्ट।

— मैजेंटा
स्रोत

आप बदल कर अपनी संख्या में वृद्धि कर सकते हैं f(m-g,g)करने के लिए f(m-g,m)।

— बस सुंदर कला

या f(m-g,i)। इसके अलावा, पहली पंक्ति के अंत में, आप एक संख्या का उपयोग करते हैं। मेरा मानना है कि आप उपयोग करने के लिए थे n+g, जिसके बारे में मैं बताऊंगा n+nकि वह बड़ा होगा।

— ब्यूटीफुल आर्ट

आप ट्रू के लिए लेन ('' '') को बदलकर कुछ बाइट्स बचा सकते हैं

— ब्रायन मिंटन

और बड़ी संख्या के लिए ord ('^?') (जहाँ ^? DEL वर्ण, ASCII 127) का उपयोग करें। EDIT ने कभी बुरा नहीं माना, यह "प्रिंट करने योग्य" नहीं है।

— ब्रायन मिंटन

@ ब्रायनमिंटन कौन कहता है कि इसे प्रिंट करने योग्य होना चाहिए?

— ब्यूटीफुल आर्ट

4

जावास्क्रिप्ट 98 चार्ट

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(m.E<<k<<k<<k<<m.E);i+=j)a+=k;alert(a)

2.718e + 239622337 ↑↑ 10 32 2.9232195202 उत्पन्न करता है

2.718e + 239622331 ↑↑ 10 32 2.9232195197 से थोड़ा अधिक के स्कोर के लिए

जो सबसे बड़ा है मैं इसे बिना ब्राउजर क्रैश किए बना सकता हूं।

(कंसोल.लॉग (ए) आपको पूरा आउटपुट दिखाएगा)

इन्हें न चलाएं:

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<(k<<k<<k<<k<<k<<k<<k);i+=j)a+=k;alert(a)

लंबे समय तक उत्तर की तुलना में 2.718 + e121333054704 ↑↑ 10 89 3.0189898069 (उर्फ 2.718 * 10 ^ (1.213 * 10 ^ 12) का उत्पादन होगा:

अधिक चरम संस्करण, यदि यह आपके ब्राउज़र को क्रैश नहीं करता है: (80 char)

m=Math;a=k=(''+m.E).replace('.',"");j=m.PI%(a&-a);for(i=j;i<k;i+=j)a+=k;alert(a)

जो ई * 10 ^ (10 ^ 19) ^ 10 10 3.106786869689 के समान आकार के आसपास एक संख्या बनाएगा

संपादित करें: अद्यतन कोड मूल समाधान केवल 2.718e + 464 उत्पन्न करता है

— serakfalcon
स्रोत

3

पायथन 3: 98 वर्ण, on 10 3 256

एक चर-तर्क फ़ंक्शन का उपयोग करना:

E=lambda n,*C:E(*([~-n][:n]+[int("%d%d"%(k,k))for k in C]))if C else n;print(E(*range(ord('~'))))

प्रभावी रूप से, ई बाकी तर्कों को बढ़ाते हुए पहला तर्क देता है, सिवाय इसके कि तर्कों में -1 डालने के बजाय यह तर्क को गिरा देता है। चूंकि प्रत्येक चक्र या तो पहले तर्क को कम करता है या तर्कों की संख्या कम करता है, इसलिए इसे समाप्त करने की गारंटी है। उपयोग किया जा रहा फ़ंक्शन int ("% d% d"% (k, k)) है, जो k ** 2 + 2 * k और 10 * k ** 2 + k के बीच परिणाम देता है। मेरा कोड * प्रतीक का उपयोग करता है - लेकिन गुणा के रूप में नहीं। इसका उपयोग तर्कों की चर संख्या के साथ काम करने के लिए किया जाता है, जो मुझे लगता है कि नियमों का पालन करना चाहिए क्योंकि नियमों का स्पष्ट बिंदु विशिष्ट संचालन को प्रतिबंधित करना था, न कि स्वयं प्रतीकों को।

ई बड़े कैसे जल्दी हो जाता है के कुछ उदाहरण:

E(1,1) = 1111
E(0,1,1) = E(11,11) = (approx) 10^8191
E(1,1,1) = E(1111,1111) = (approx) 10^(10^335)
E(2,1,1) = E(11111111,11111111) = (approx) 10^(10^3344779)

उनमें से केवल पहले दो उचित समय पर मेरे कंप्यूटर पर चलने योग्य हैं।

तब, ई द्वारा आह्वान किया जाता है E(*range(ord('~')))- जिसका अर्थ है:

E(0,1,2,3,4,5, ... ,121,122,123,124,125)

मुझे पूरी तरह से यकीन नहीं है कि यह कितना बड़ा है (मैं इसे किसी भी लाभ के लिए अनुमानित करने की कोशिश कर रहा हूं) - लेकिन यह स्पष्ट है कि यह ~ वास्तव में ~ बड़ा है।

एक उदाहरण के रूप में, लगभग बारह चक्र, परिणाम लगभग है: (तकनीकी रूप से थोड़ा अधिक)

E(2**27211,2**27211,2**27212,2**27212,2**27212,2**27212,2**27213,2**27213,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54423,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54424,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54425,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**54426,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636,2**81636)

परिणाम का अनुमान:

यदि हम इसके द्वारा बढ़ते कदम का अनुमान लगाते हैं lambda k: 10 * k**2, तो फ़ंक्शन का वर्णन किया जा सकता है

E(n, C₁, C₂, ... Cᵥ) ≈ E(10^(n²/2) ⋅ C₁²ⁿ, 10^(n²/2) ⋅ C₂²ⁿ, ... 10^(n²/2) ⋅ Cᵥ²ⁿ)
                     ≈ E(10^((10^(n²/2) ⋅ C₁²ⁿ)²/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )
                     ≈ E(10^((10^n² ⋅ C₁⁴ⁿ)/2) ⋅ C₂^(2n  ⋅ 10^(n²/2) ⋅ C₁²ⁿ), ... )

प्रासंगिक बात हम यहाँ कर रहे हैं दस की शक्तियों का एक टॉवर का निर्माण होता है, इसलिए अंतिम स्कोर को 10 ↑↑ 256 के रूप में अनुमानित किया जा सकता है।

बेहतर (हालांकि आंशिक) परिणाम अनुमान:

यह 10 * k**2दूसरे अनुमान के समान ही उपयोग करता है ।

E(0, b) = 10 * b**2
E(1, b) = 10 * (10 * b**2)**2 = 10 * 100 * b**4 = 10**3 * b**4
E(2, b) = 10 * (10**3 * b**4)**2 = 10 * (10**6 * b**8) = 10**7 * b**8
E(a, b) = 10**(2**(a+1)-1) * b**(2**(a+1))

पिछले अनुमान के तहत, यह होगा:

E(a, b) = 10**(a**2/a) * b**(2*a)

कौन सा है, क्योंकि यह का उपयोग करता है वास्तविक मूल्य की तुलना में काफी छोटा होता है a**2के बजाय 2**a10 के लिए और का उपयोग करता है a*2के बजाय 2**aख के लिए।

— सेल स्केग
स्रोत

मैंने आपके परिणाम का अनुमान लगाया, असहमत महसूस किया।

— को बंद करना

मुझे उस परिणाम से असहमत होना होगा। एक बार जब मैं अपना तर्क टाइप करता हूं।

— सेल स्केग्स

हम वहाँ चलें। जैसा कि मैंने अपडेट में कहा है, आपका अनुमान वास्तविक मूल्य से काफी छोटा प्रतीत होता है।

— सेल स्केग्स

काफी उचित है, लेकिन किसी भी दर पर हमें स्कोरिंग सूची में इस उत्तर को शामिल करने के लिए केवल एक कदम नहीं, बल्कि एक पुनरावर्ती-प्रेरक / कम-से-कम अनुमान की आवश्यकता है। मुझे यकीन है कि आपका स्कोर पुनरावर्ती की तुलना में बेहतर है , लेकिन यह भी यकीन है कि इल्मरी करोनन की तुलना में बेहतर नहीं है (जो वैसे भी बहुत विस्तार योग्य है, इस समय केवल 18 पात्रों का उपयोग कर रहा है), इसलिए मुझे लगता है कि मेरा अनुमान काफी अच्छा है स्कोरिंग उद्देश्य।

— को बंद करना

मैं सहमत हूँ। मैं देखूंगा कि क्या मैं इस पर अधिक काम कर सकता हूं और कम से कम परिणाम के लिए अधिक सटीक कम बाध्यता के साथ आ सकता हूं।

— सेल स्केग्स

3

सी (स्कोर (10 ^ 20 000 000 000 ↑↑ 10 5 3.005558275)

~ 20 जीबी आउटपुट
41 अक्षर (41 ^ 3 का मतलब कुछ नहीं)

main(){for(;rand();printf("%d",rand()));}

rand()आउटपुट के बावजूद नियतात्मक है क्योंकि कोई बीज कार्य नहीं है।

— ybeltukov
स्रोत

यदि आप अशुभ हैं, तो आपका कार्यक्रम एक पुनरावृत्ति के बाद बंद हो जाता है और rand()समाप्ति की स्थिति के लिए कॉल इसे गैर निर्धारक बनाता है। इसके अलावा rand()हर पुनरावृत्ति में कॉल करने से इसे बहुत धीमा होना चाहिए। इसके बजाय LONG_MAXपरिभाषित की तरह कुछ का उपयोग करें limits.h।

— klingt.net

ठीक है मैं non deterministicपीछे ले जाता हूं , क्योंकि आपके लिखे जैसा कोई बीज नहीं है।

— klingt.net

1

कैसे के ~' 'बजाय के rand()साथ, के साथ मुद्रित %u? दो बाइट्स कम स्रोत, और एक उच्च मूल्य।

— 9

सबसे बड़ी संख्या मुद्रण योग्य

लीडरबोर्ड

GolfScript; स्कोर कम से कम f 0_0 + ω + 1 (17) / 1000

विंडोज 2000 - विंडोज 8 (3907172/23 32 = 321)

GolfScript, स्कोर: जिस तरह से बहुत ज्यादा

जावास्क्रिप्ट 44 चार्ट

सी, स्कोर = 10 10 97.61735 / 98 3 ↑↑ 10 87 2.29874984

अजगर 3 - 99 वर्ण - (सबसे अधिक संभावना है) ग्राहम की संख्या से काफी बड़ा है

आकार का विश्लेषण

पर्ल - स्कोर ↑↑ 10 - 4.1

पर्ल - स्कोर ↑↑ 10। 4

जावास्क्रिप्ट, 10 ↑↑↑↑ 210

बेहतर स्कोर: 10 ↑↑ 13

स्कोर: ↑↑ 10 10 10 10 10 16 ↑↑ 10 66 6.080669764

में इस

Iteration 1

Iteration 2

Iteration 3

गर्भाधान ४

Iteration 5

विश्लेषणात्मक स्कोर

लाटेक्स के स्रोत

एपीएल, 10 ↑↑ 3.4

हास्केल, स्कोर: (2 2 2 65536 -3) / 1000000 ↑↑ 2 ≈ 7 ↑↑ 10 77 4.6329710779

पायथन, 2/11/830584 ↑↑ 10 9 8.632971 (नथ अप एरो नोटेशन)

गोल्फस्क्रिप्ट 3.673e + 374

रूबी, संभावित रूप से अनंत, 54 वर्ण

GolfScript, ≈ च ε 0 (च ε 0 (च ε 0 (च ε 0 (च ε 0 (च ε 0 (च ε 0 (च ε 0 (च ε 0 (126)))))))))

डीसी, 100 अक्षर

सी: अधिक से अधिक 10 (2 64 -1) 2 64 है, जो खुद से अधिक 10 10 355393490465494856447 ≈ 10 ↑↑ ४.१,१८,२०,७४४

C: 10 ^ 10 ^ 136 ↑↑ 10 9 3.329100567

आर - कोड के ४ ९ ४१ अक्षर, 4.03624169270483442 * 10 ^ 5928 ↑↑ 10 13 2.576691348

ECMAScript 6 - 10 ^ 3 AS 3/884736

सी

नई रूबी: स्कोर ~ एफ ω 1262 +1 (126 2 2 126 )

अघोषित कोड:

स्पष्टीकरण:

उदाहरण:

हास्केल - एकरमैन फ़ंक्शन ने अपने परिणाम पर 20 बार - 99 वर्णों पर लागू किया

x86 मशीन कोड - 100 बाइट्स (MSDOS .com फ़ाइल के रूप में इकट्ठे)

GNU बैश, 10 ^ 40964096 B / 80 ^ 3 ^ 10 ≈ 2.072820169

सी, 10 ^ 10 ^ 2485766 ↑↑ 10 5 3.805871804

पॉवर्सशेल (2.53e107976 / 72 6. = 6.78e107970 (10 01 1.701857171)

पायथन 3, स्कोर = ack (126,126) / 100 ^ 3

जावास्क्रिप्ट 98 चार्ट

इन्हें न चलाएं:

पायथन 3: 98 वर्ण, on 10 3 256

परिणाम का अनुमान:

बेहतर (हालांकि आंशिक) परिणाम अनुमान:

सी (स्कोर (10 ^ 20 000 000 000 ↑↑ 10 5 3.005558275)

GolfScript; स्कोर कम से कम f _{0_0 + ω + 1} (17) / 1000

सी, स्कोर = 10 ^{10 ^97.61735} / 98 ³ ↑↑ 10 87 2.29874984

स्कोर: ↑↑ ^{10 10 ^{10 ^{10 ^{10 ¹⁶}}}} ↑↑ 10 66 6.080669764

हास्केल, स्कोर: (2 ^{2 ^{2 ⁶⁵⁵³⁶}} -3) / 1000000 ↑↑ 2 ≈ 7 ↑↑ 10 77 4.6329710779

GolfScript, ≈ च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (च _{ε ₀} (126)))))))))

सी: अधिक से अधिक 10 ^{(2 ⁶⁴ -1) ^{2 ⁶⁴}} है, जो खुद से अधिक 10 ^{10 ^{355393490465494856447}} ≈ 10 ↑↑ ४.१,१८,२०,७४४

नई रूबी: स्कोर ~ एफ _{ω ¹²⁶² +1} (126 ² 2 ¹²⁶ )