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

Question

निम्न आवश्यकताओं को पूरा करते हुए सबसे कम संभव कार्यक्रम (बाइट्स में मापी गई लंबाई) लिखें:

• कोई निवेश नहीं
• उत्पादन को रोकना है
• निष्पादन अंततः समाप्त हो जाता है
• आउटपुट बाइट्स की कुल संख्या ग्राहम की संख्या से अधिक है

मान लें कि कार्यक्रमों जब तक "सामान्य" एक पर समाप्ति चलाने आदर्श कंप्यूटर ¹ पहुँच असीमित संसाधनों करने में सक्षम है, और आम प्रोग्रामिंग भाषाओं यदि आवश्यक हो तो इसकी अनुमति देना (सिंटेक्स बदले बिना) संशोधित कर रहे हैं कि। इन मान्यताओं के कारण, हम इसे एक प्रकार का Gedankenexperiment कह सकते हैं।

चीजें शुरू करने के लिए, यहां एक 73-बाइट रूबी प्रोग्राम है जो तेजी से बढ़ते पदानुक्रम में f _{ω + 1} (99) की गणना करता है :

f=proc{|k,n|k>0?n.times{n=f[k-1,n]}:n+=1;n};n=99;n.times{n=f[n,n]};puts n

¹ संपादित करें: अधिक सटीक, मान लें कि हम एक मौजूदा प्रणाली ले रहे हैं और इसे केवल स्टोरेज साइज पर कोई ऊपरी सीमा नहीं है (लेकिन यह हमेशा सीमित है)। निर्देशों के निष्पादन-समय को संशोधित नहीं किया जाना चाहिए, लेकिन मशीन को आदर्श माना जाता है कि इसकी परिचालन जीवनकाल में कोई ऊपरी सीमा नहीं होगी।

Comments

यह मेरे टेट्रेशन प्रश्न को एक नए स्तर पर ले जाता है!

— मेज़ैंडर

एक बार एक ऐसी ही प्रोग्रामिंग प्रतियोगिता थी जिसे बिग्नम बेकोफ कहा जाता था। कुछ प्रविष्टियाँ काफी दिलचस्प हैं; परिणाम यहां हैं: djm.cc/bignum-results.txt

— डैनी चिया

Answer 1

गोल्फस्क्रिप्ट ( 49 47 वर्ण)

4.,{\):i\.0={.0+.({<}+??\((\+.@<i*\+}{(;}if.}do

बहुत सारे स्पष्टीकरण के लिए एक कीड़े का जीवनकाल देखें । संक्षेप में, यह च से बड़ी संख्या प्रिंट _{ω ^ω} (2)।

Comments

f_ (about ^ ω) (2) लगभग g_ (f_8 (8)) जितना बड़ा है, इसलिए उतनी अधिक ओवरकिल नहीं है जितनी कि अभिव्यक्ति होगी।

— बस सुंदर कला

Answer 2

हास्केल, _{59 57 55} 63

(f%s)1=s;(f%s)n=f.(f%s)$n-1
main=print$((flip((%3)%(3^))3)%4)66

यह कैसे काम करता है: %बस एक फ़ंक्शन लेता है और इसके n-1शीर्ष पर कई बार रचना करता है s; यानी %3एक फंक्शन लेता है fऔर एक फंक्शन लौटाता है , जो एक पंक्ति में nइसे f3 n-1बार लागू करने के बराबर होता है । यदि हम इस उच्च-क्रम फ़ंक्शन के अनुप्रयोग को पुन: व्यवस्थित करते हैं, तो हमें फ़ंक्शंस का तेजी से बढ़ने वाला अनुक्रम मिलता है - एक्सप्रेशन के साथ शुरू करना, यह वास्तव में नुथ-एरो-फ़ॉरेस्ट आकारों का अनुक्रम है:
((%3)%(3^))1 n = (3^)n     = 3ⁿ = 3↑n
((%3)%(3^))2 n = ((3^)%3)n = (3↑)ⁿ⁻¹ $ 3 = 3↑↑n
((%3)%(3^))3 n = (((3^)%3)%3)n = (3↑↑)ⁿ⁻¹ $ 3  = 3↑↑↑n
और इसी तरह। ((%3)%(3^))n 3वह है 3 ↑ⁿ 3, जो ग्राहम की संख्या की गणना में दिखाई देता है। यह सब करना छोड़ दिया है समारोह की रचना है(\n -> 3 ↑ⁿ 3) ≡ flip((%3)%(3^))3ग्राहम की संख्या से बड़ी संख्या पाने के लिए, 64 से अधिक बार, 4 के ऊपर (गणना के साथ तीर की संख्या शुरू होती है)। यह स्पष्ट है कि लघुगणक (क्या एक बहुत धीमी गति से काम करता है!) g₆₅अभी भी की तुलना में बड़ा है g₆₄=G, इसलिए यदि हम उस संख्या को प्रिंट करते हैं तो आउटपुट की लंबाई अधिक हो जाती है G।

⬛

Comments

जब मैं इसके साथ परीक्षण करता हूं print$((flip((%3)%(3*))3)%2)1, तो एक रन-टाइम त्रुटि है - क्या आप कह सकते हैं कि क्यों? यह तब सफल होता है जब 2इसे बदल दिया जाता है 1(आउटपुट 81)।

— रेस

ओह ... आइडोन 32-बिट संस्करण को चलाने के लिए लगता है, इसलिए यह Intजल्दी से अतिप्रवाह हो जाता है । 64-बिट सिस्टम पर, जो पुन: पेश करने के लिए बहुत अधिक मेमोरी का उपभोग करता है, लेकिन निश्चित रूप से यह अभी भी पहुंचने की अनुमति नहीं देगा G। मुझे (बड़े-इंट) Integerप्रकार की आवश्यकता है, इसलिए मैं उपयोग नहीं कर सकता !!; प्रतीक्षा करें ...

— काउंटरक्ल्विस

इसे अभी तय किया गया था, इसे लागू करने के लिए स्पष्ट पुनरावृत्ति का उपयोग करना था %।

— को बंद करना

मुझे लगता है कि ((%3)%(3*))2 nवास्तव में आप (एक अच्छी बात) की तुलना में तेजी से बढ़ते हैं , लेकिन मेरे हास्केल-फू को समझने में अपर्याप्त है कि क्यों। के लिए n = 0, 1, 2, ..., देने के बजाय 3, 3^3, 3^(3^3), ..., यह देता है 3, 3^(3+1), 3^((3^(3+1))+1), ...।

— रेस

जैसा कि मैंने कहा: " ((%3)%(3*))n 3से बड़ा है 3 ↑ⁿ 3"। या आप कुछ और मतलब है? वैसे भी, मैंने परिभाषा को बदल दिया है ताकि यह सभी समानताएं हो (कम से कम मुझे ऐसा लगता है, अब जांच करने के लिए आलसी करने के लिए ...) बड़े-थेल्स के बजाय। और अगर आप बदल 66जाते हैं 65, तो यह वास्तव में Gखुद को पैदा करता है, यह अच्छा नहीं है?

— वामावर्तियों को चालू करना बंद कर दिया

Answer 3

पायथ , 29 28 बाइट्स

M?*GHgtGtgGtH^ThH=ZTV99=gZTZ

हाइपर-ऑपरेशन के लिए एक लैम्ब्डा को परिभाषित करता है और पुन: इसे कॉल करता है। ग्राहम की संख्या के लिए परिभाषा की तरह, लेकिन बड़े मूल्यों के साथ।

यह:

M?*GHgtGtgGtH^3hH

एक मेमने को परिभाषित करता है, लगभग अजगर के बराबर

g = lambda G, H:
  g(G-1, g(G, H-1)-1) if G*H else 3^(H+1)

यह हाइपर-ऑपरेशन फ़ंक्शन, जी (जी, एच) = 3 ^{1 जी + 1} (एच + 1) देता है।
इसलिए, उदाहरण के लिए, जी (1,2) = 3 = ² 3 = 7,625,597,484,987, जिसे आप यहां परीक्षण कर सकते हैं ।

V<x><y>एक लूप शुरू करता है जो शरीर y, xसमय को निष्पादित करता है ।
=gZTयहाँ लूप का शरीर है, जो इसके बराबर हैZ=g(Z,10)

कोड:

M?*GHgtGtgGtH^3hH=Z3V64=gZ2)Z

ग्राहम का नंबर देते हुए, हाइपरोपरेशन को 64 बार से ऊपर कॉल करना चाहिए।

मेरे जवाब में, हालांकि, मैंने एकल अंकों को बदल दिया है T, जिसे 10 के लिए आरंभीकृत किया गया है, और पुनरावृत्ति की गहराई को 99 तक बढ़ा दिया है। ग्राहम ऐरे नोटेशन का उपयोग करते हुए , ग्राहम की संख्या [3,3,4,64] है, और मेरी कार्यक्रम बड़ा [10,11,11,99] आउटपुट करता है। मैंने भी )एक बाइट को बचाने के लिए लूप को बंद कर दिया है , इसलिए यह 99 पुनरावृत्तियों में प्रत्येक क्रमिक मूल्य को प्रिंट करता है।

Answer 4

अजगर (111 + एन), एन = लंबाई (एक्स)

हालाँकि यह उत्तरदाता के रूबी कार्यक्रम जितना छोटा नहीं है, फिर भी मैं इस संभावना को पूरा करने के लिए इसे पोस्ट करूँगा।

यह एकरमन फ़ंक्शन का उपयोग करता है, और एकरमन फ़ंक्शन के लिए एक और कॉल से मूल्यों के साथ एम और एन के साथ एकरमन फ़ंक्शन को कॉल करता है, और 1000 बार पुनरावर्ती करता है।

यह शायद ग्राहम की संख्या से बड़ा है, लेकिन मुझे यकीन नहीं है, क्योंकि किसी को भी इसकी सही लंबाई का पता नहीं है। इसे आसानी से बढ़ाया जा सकता है, अगर यह बड़ा न हो।

x=999
b='A('*x+'5,5'+')'*x
def A(m,n):n+1 if m==0 else A(m-1,A(m,n-1)if n>0 else 1)
exec('print A('%s,%s')'%(b,b))

Comments

उत्पादन करने के लिए stdout? भी, आप एक returnबयान या एक की जरूरत है lambda।

— बूथ

इसके अलावा अगर A (m, n) एकल मान लौटाता है, तो क्या A (A (5,5)) एक तर्क याद नहीं कर रहा है? ... यह इस तरह की चुनौती के साथ समस्या है: यह लोगों को अपने कोड का परीक्षण न करने के लिए प्रोत्साहित करता है, क्योंकि एक पूर्ण रन विशुद्ध रूप से सैद्धांतिक है।

— ब्रेडबॉक्स

यदि आप अपनी अंतिम पंक्ति को बदलते हैं exec'x=A(x,x);'*x;print x, तो प्रोग्राम ठीक है और आउटपुट लगभग f_ (your + 1) (x) है (यह मानकर कि ऐकर्मन फ़ंक्शन कोड सही है), जिसमें x = 99 के लिए भी G बाइट्स से अधिक है, कहें । (मेरी रूबी कार्यक्रम में, f[m,n]का एक संस्करण है A(m,n)।)

— रेस

@breadbox - अच्छा बिंदु ... इस तरह के सैद्धांतिक प्रश्नों से हमें यह सुनिश्चित करने की आवश्यकता है कि एक कार्यक्रम छोटे पैरामीटर (यानी गैर-सैद्धांतिक) परीक्षण-मामलों के लिए ठीक है जो स्पष्ट रूप से एक सही उत्तर देने के लिए सामान्यीकृत करते हैं।

— रेस

यह अधिक लंबा है, लेकिन यदि आप evalइसके बजाय उपयोग करना चाहते हैं exec, तो आपकी अंतिम पंक्ति हो सकती है f=lambda x:A(x,x);print eval('f('*x+'x'+')'*x)। इसके अलावा, ए (एम, एन) के अपने प्रति को प्रति बूथबी की टिप्पणी को ठीक करने की आवश्यकता है।

— रेस

Answer 5

रूबी, 54 52 50 बाइट्स

f=->b{a*=a;eval"f[b-1];"*b*a};eval"f[a];"*a=99;p a

---

रूबी, 85 81 76 71 68 64 63 59 57 बाइट्स

f=->a,b=-a{eval"a*=b<0?f[a,a]:b<1?a:f[a,b-1];"*a};p f[99]

F (a + 1)> f ( _{+ 1} (a) के साथ बहुत तेजी से बढ़ता हुआ पदानुक्रम ।

---

रूबी, 61 बाइट्स

f=->a,b=-a{a<0?9:b==0?a*a:f[f[a-1,b],b>0?b-1:f[a,b+1]]};f[99]

मूल रूप से एक Ackermann फ़ंक्शन एक मोड़ के साथ।

---

रूबी, 63 59 बाइट्स

n=99;(H=->a{b,*c=a;n.times{b ?H[[b-1]*n*b+c]:n+=n}})[n];p n

---

एक और रूबी, 74 71 बाइट्स

def f(a,b=a)a<0?b:b<0?f(a-1):f(a-1,f(a,b-1))end;n=99;n.times{n=f n};p n

मूल रूप से एकरमैन अपने आप में 99 बार कार्य करता है।

Answer 6

अजगर: 85

f=lambda a,a:a*a
exec'f=lambda a,b,f=f:reduce(f,[a]*b,1)'*99
exec'f('*64+'3'+',3)'*64

जिसे शायद :४ +length(X) तक छोटा किया जा सकता है :

f=lambda a,a:a*a
exec'f=lambda a,b,f=f:reduce(f,[a]*b,1)'*int('9'*X)
f(3,3)

कहाँ Xएक उपयुक्त बड़ी संख्या है जैसे कि परिणामी हाइपरोपरेशन ग्रैहम 3, 3नंबर से बड़ा है (यदि यह संख्या कम है 99999999999तो कुछ बाइट बच जाती है)।

---

नोट: मुझे लगता है कि अजगर कोड इंटरैक्टिव दुभाषिया पर क्रियान्वित किया जाता है इसलिए परिणाम स्टडआउट के लिए मुद्रित किया जाता है, अन्यथा 9कॉल के लिए प्रत्येक समाधान के लिए बाइट्स जोड़ें print।

Comments

आपका 74ish बाइट समाधान एक आउटपुट का उत्पादन लगभग पर्याप्त नहीं करता है।

— lirtosiast

Answer 7

जावास्क्रिप्ट, 83 बाइट्स

एक और एकरमैन फंक्शन सॉल्यूशन।

(function a(m,n,x){return x?a(a(m,n,x-1),n,0):(m?a(m-1,n?a(m,n-1):1):n+1)})(9,9,99)

Answer 8

जावास्क्रिप्ट, 68 बाइट्स, हालांकि ES6 का उपयोग करने के लिए अक्षम है

a=(x,y)=>y?x?a(a(x-1,y)*9,y-1):a(9,y-1):x;b=x=>x?a(9,b(x-1)):9;b(99)

a फ़ंक्शन बेस -9 के साथ अप-एरो नोटेशन के समान है।

       /a(a(x-1,y)*9,y-1)  x>0, y>0
a(x,y)=|a(9,y-1)           x=0, y>0
       \x                  y=0

bफंक्शन है: b (x) = b ^x (9)।

b(99)ग्राहम की संख्या <f ( _{+ 1} (64) की तुलना में ~ f ~ _{+ 1} (99 ) है।

Comments

यदि आपने प्रश्न के मुकाबले भाषा के नए होने के कारण इस गैर-प्रतिस्पर्धी को चिह्नित किया है, तो आपको अब ऐसा करने की आवश्यकता नहीं है

— जो राजा