यदि कोई कार्यक्रम समाप्त हो जाता है और इसे देखने वाला कोई नहीं है, तो क्या यह रुकता है?


99

यह सच्चाई का सामना करने का समय है: हम हमेशा के लिए यहां नहीं रहेंगे, लेकिन कम से कम हम एक कार्यक्रम लिख सकते हैं जो मानव जाति को पछाड़ देगा भले ही वह समय के अंत तक संघर्ष करे।

आपका कार्य एक ऐसे कार्यक्रम को लिखना है, जिसमें ब्रह्मांड के अंत तक शेष समय से अधिक चलने की उम्मीद है।

आप मान सकते हैं कि:

  • ब्रह्मांड 10 1000 वर्षों में एन्ट्रापी से मर जाएगा ।
  • आपका कंप्यूटर:
    • ब्रह्मांड को पछाड़ देगा, क्योंकि यह Unobtainium से बना है ।
    • अनंत स्मृति / स्टैक / पुनरावृत्ति सीमा है।
    • इसके प्रोसेसर की सीमित गति है।

आपको यह दिखाना होगा कि आपका कार्यक्रम समाप्त हो गया है (क्षमा करें, कोई अनंत छोरें नहीं) और इसके अपेक्षित समय की गणना करें।

मानक कमियां लागू होते हैं।

यह एक कोड गोल्फ चुनौती है, इसलिए सबसे छोटा कोड मानदंड जीत को संतुष्ट करता है।

संपादित करें :

दुर्भाग्य से, यह (30 मिनट बाद) पाया गया कि Unobtainium की असंभव क्षेत्र कंप्यूटर की आंतरिक घड़ी के साथ हस्तक्षेप करता है, इसे बेकार प्रदान करता है। इसलिए समय आधारित कार्यक्रम तुरंत रुक जाते हैं। (जो एक कार्यक्रम छोड़ देगा जो बस अपनी जीवित विरासत के रूप में इंतजार कर रहा है, वैसे भी?)।

कंप्यूटर प्रोसेसर इंटेल i7-4578U के समान है, इसलिए रनिंग टाइम को मापने का एक तरीका यह है कि आप अपने प्रोग्राम को इसी तरह के कंप्यूटर में एक छोटे इनपुट के साथ चलाएं (मुझे उम्मीद है) और इसके रनिंग टाइम को एक्सट्रापोल करें।


मंच

#CharsLanguageUpvotes        Author        
1    5      CJam              20       Dennis                  
2    5      J                      5         algorithmshark      
3    7      GolfScript       30       Peter Taylor          
4    9     Python             39       xnor                      
5    10   Matlab             5         SchighSchagh      

* ३१/० 31 पर अपवोट


40
मुझे इस प्रश्न के लिए एक [सबसे धीमा-कोड] टैग बनाने का प्रलोभन दिया गया। : पी
दरवाज़े

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

49
आपका शीर्षक एक टीशर्ट होना चाहिए
उपयोगकर्ता -२१४26४'२६३ 25३

4
अच्छा सवाल है, लेकिन क्या यह लोकप्रियता प्रतियोगिता नहीं होनी चाहिए?
IazertyuiopI

जवाबों:


34

CJam, 5 बाइट्स

0{)}h

यह काम किस प्रकार करता है

 0   " Push 0.                                 ";
 {   "                                         ";
   ) " Increment the Big Integer on the stack. ";
 }h  " Repeat if the value is non-zero.        ";

यह कार्यक्रम तब रुक जाएगा जब ढेर बिग इंटेगर को अब स्टोर नहीं कर सकता है, जो कि आधुनिक डेस्कटॉप कंप्यूटर पर कभी भी नहीं होगा।

मेरे कंप्यूटर पर डिफ़ॉल्ट ढेर का आकार 4,179,623,936 बाइट्स है (जावा 8 फेडोरा पर)। इसके साथ एक मनमाना मूल्य तक बढ़ाया जा सकता है -Xmx, इसलिए केवल वास्तविक सीमा उपलब्ध मुख्य मेमोरी है।

मृत्यु का समय

यह मानते हुए कि दुभाषिया की जरूरत है एक्स एक गैर नकारात्मक बिग पूर्णांक स्टोर करने के लिए कम से कम स्मृति के टुकड़े 2 एक्स , हम अप करने के लिए गिनती करने के लिए है 2 8 × +४१७९६२३९३६ = 2 +३३४३६९९१४८८ । प्रति घड़ी चक्र में एक वृद्धि और मेरे कोर i7-3770 (टर्बो के साथ 3.9 गीगा) के साथ, यह 2 33,436,991,488 ÷ 3,400,000,000> 10 10,065,537,393 सेकंड का समय लेगा , जो 10 106565,537,385 वर्षों से अधिक है।


14
मुझे नहीं लगता कि आप परिमित संसाधनों पर भरोसा कर सकते हैं, क्योंकि प्रश्न में कहा गया है कि "आपके कंप्यूटर में असीम मेमोरी / स्टैक / रिकर्सन लिमिट" है।
ग्रेग हेवगिल

4
अनंत स्मृति !=अनंत डेटा प्रकार। अगर मेरे पास RAM की टेराबाइट है, तो एक अहस्ताक्षरित 8-बिट पूर्णांक अभी भी केवल 255 तक जाता है।
wchargin

6
@GregHewgill: असीमित संसाधनों के साथ, आप अधिकतम जावा हीप आकार को किसी भी मनमाने मूल्य तक बढ़ा सकते हैं , लेकिन यह हमेशा सीमित रहेगा।
डेनिस

2
@ डेनिस, लेकिन फिर ढेर के आकार को दोगुना करने के लिए लूप के माध्यम से हर बार बस एक पंक्ति जोड़ें। यह
शिशुओं के

9
@CarlWitthoft: आप प्रोग्राम के अंदर से ऐसा नहीं कर सकते।
डेनिस

62

जावास्क्रिप्ट, ३ ९

(function f(x){for(;x!=++x;)f(x+1)})(0)

व्याख्या

चूंकि जावास्क्रिप्ट बड़े पूर्णांक का ठीक से प्रतिनिधित्व नहीं करता है, लूप for(;x!=++x;)एक बार xहिट हो जाता है 9007199254740992

लूप के लिए बॉडी निष्पादित की जाएगी Fib(9007199254740992) - 1, जहां Fib(n)nth रिट्रेसमेंट नंबर है।

परीक्षण से, मुझे पता है कि मेरा कंप्यूटर 150,000 से अधिक पुनरावृत्तियों को प्रति सेकंड कम करेगा। वास्तव में, यह बहुत धीमी गति से चलेगा क्योंकि ढेर बहुत बड़ा हो जाएगा।

इस प्रकार, कार्यक्रम (Fib(9007199254740992) - 1) / 150000को चलने में कम से कम सेकंड लगेंगे । मैं गणना करने में सक्षम नहीं हूं Fib(9007199254740992)क्योंकि यह इतना बड़ा है, लेकिन मुझे पता है कि यह 10 1000 से बहुत बड़ा है * 150,000 ।

संपादित करें: जैसा कि टिप्पणियों में बताया गया है, Fib(9007199254740992)लगभग 4.4092 * 10 1882393317509686 है , जो वास्तव में काफी बड़ा है।


9
चूंकि fib(n)इसका अनुमान लगाया जा सकता है phi^n, हम यह log((sqrt(5) + 1)/2)*9007199254740992गणना करने के लिए उपयोग कर सकते हैं कि fib(9007199254740992)इसके बारे में कितने अंक निकलते हैं 1.8823933*10^15
overactor

11
@overactor, वुल्फराम अल्फा के अनुसार, Fib(9007199254740992)(निरंतर रूप के साथ उपयोग करना phi) लगभग है 4.4092... * 10^1882393317509686गणना
ब्रायन एस

1
बढ़ते स्टैक सीपीयू की गति को कम नहीं करता है ... जब तक कि आप सीमित मेमोरी एड्रेस लाइन की चौड़ाई / असीमित एड्रेस चौड़ाई को ध्यान में नहीं रखते हैं (जिस स्थिति में मंदी अभी भी उचित एन्कोडिंग मानते हुए पता लंबाई में रैखिक है) या मेमोरी स्टोरेज में भौतिक सीमाएं और प्रकाश की गति (जिस स्थिति में मंदी स्थानिक भंडारण मान पते में मंदी होती है, यहां तक ​​कि डेटा घनत्व का डीएनए स्तर अंततः जोड़ना शुरू कर देता है, भले ही आप अंतरिक्ष-कुशल यादृच्छिक पहुंच का प्रबंधन करते हों)
जॉन ड्वोरक

1
@JamesKhoury नहीं, आपके द्वारा लिखा गया फ़ंक्शन केवल समकक्ष है for(x=0;x!=++x;)और केवल 9007199254740992 बार पुनरावृत्त करता है।
पीटर ओल्सन

4
@SylvainLeroux रैम की अनंत मात्रा के साथ एक वास्तुकला शायद सिर्फ ढेर और स्टैक को इंटरलेवे करेगा और उन दोनों को ऊपर की तरफ बढ़ेगा।
जॉन ड्वोरक

47

पायथन (9)

9**9**1e9

इसमें 10 ** 10000000 से अधिक बिट्स हैं, इसलिए इसकी गणना करने से हमें गर्मी से होने वाली मृत्यु से दूर ले जाना चाहिए।

मैंने जांच की कि इससे बड़े लेकिन अभी भी उचित मूल्यों के लिए अधिक से अधिक समय लगता है, इसलिए यह केवल दुभाषिया द्वारा अनुकूलित नहीं किया जा रहा है।

संपादित करें: @ user2357112 पर मुर्गों के धन्यवाद को हटाकर दो चार्ट लगाए गए। टीआईएल है कि पाइथन एक बिजली टॉवर के रूप में क्रमिक घातांक का इलाज करता है।


4
OverflowError: (34, 'परिणाम बहुत बड़ा')
Apple16

93
@ Apple16 आपके कंप्यूटर पर हो सकता है, लेकिन मेरी एक "अनंत स्मृति / स्टैक / रिकर्सन लिमिट" है।
xnor

64
इट्स ओके, दोस्तों। मैंने इसे अंतिम ब्रह्मांड चलाया और ब्लैक होल के पतन...82528057365719799011536835265979955007740933949599830498796942400000000009 से बचने के लिए (2.6 * 10 ^ 954242509 अंक छोड़ा गया )। आपको वास्तव में Unobtanium में अपग्रेड करना चाहिए।
xnor

10
घातांक सही-सहयोगी है, इसलिए आप कोष्ठकों को छोड़ सकते हैं।
user2357112

10
यह ध्यान देने योग्य है कि 9**9**9e9बस के रूप में छोटा है और गणना करने के लिए थोड़ा और ब्रह्मांड-लंबाई लेता है, साथ ही साथ थोड़ा अच्छा लग रहा है।
abarnert

35

GolfScript ( 12 7 वर्ण)

9,{\?}*

यह गणना करता है और 8 ^ 7 ^ 6 ^ 5 ^ 4 ^ 3 ^ 2 ~ = 10 ^ 10 ^ 10 ^ 10 ^ 183230 प्रिंट करता है। इसे 10 ^ 1000 वर्ष ~ = 10 ^ 1007.5 सेकंड में (गणना में कभी भी बुरा न मानने) के लिए, इसे प्रति सेकंड लगभग 10 ^ (10 ^ 10 ^ 10 ^ 183230 - 10 ^ 3) अंकों को प्रिंट करने की आवश्यकता होती है।


22
लेकिन यह बहुत पहले रुक जाएगा कि एक "प्रिंटर पेपर से बाहर" संदेश के साथ ...
फ्लोरिस

1
@ फ़्लोरिस इन दिनों कौन भौतिक मीडिया का उपयोग करता है?
जॉन ड्वोरक

3
@JanDvorak, मैंने अभी माना कि फ्लोरिस और उसे उखाड़ने वाले 7 लोग मेरे दादाजी की पीढ़ी के हैं, जब सभी आउटपुट निरंतर फीड पेपर के लिए थे।
पीटर टेलर

2
@PeterTaylor - हो सकता है काफी नहीं है कि वर्ष है, लेकिन मैं कर रहा हूँ काफी पुरानी "बैच नौकरियों" सबमिट करने के याद करने के लिए "कंप्यूटर" (दिनों जब वहाँ 20k के एक छात्र जनसंख्या, जो कंप्यूटर आप का मतलब में कोई संदेह नहीं था, में) करने के लिए, और अगले दिन प्रिंटआउट एकत्र करना। आप (7 अन्य) ने सही ढंग से यह कहा कि यह हास्य का एक प्रयास था, न कि आपकी उत्कृष्ट और हास्यास्पद लघु पटकथा की गंभीर आलोचना।
फ्लोरिस

35

Marbelous 68 66 बाइट्स

}0
--@2
@2/\=0MB
}0@1\/
&0/\>0!!
--
@1
00@0
--/\=0
\\@0&0

Marbelous एक 8 बिट भाषा है जिसमें केवल Rube Goldberg-like मशीन में मार्बल्स द्वारा दर्शाए गए मान हैं, इसलिए यह बहुत आसान नहीं था। यह दृष्टिकोण लगभग निम्नलिखित छद्म कोड के बराबर है:

function recursiveFunction(int i)
{
    for(int j = i*512; j > 0; j--)
    {
        recursiveFunction(i - 1);
    }
}

चूँकि अधिकतम मान 256 है, (मार्बलस प्रोग्राम में 0 से दर्शाया जाता है, जिसे अलग-अलग जगहों पर अलग-अलग तरीके से हैंडल किया जाता है) रिकर्सिवफंक्शन (1) को कुल मिलाकर कहा जाएगा, 256!*512^256जो 10^1200ब्रह्मांड को रेखांकित करने के लिए आसानी से पर्याप्त है।

मारबेलस के पास बहुत तेज़ दुभाषिया नहीं है, ऐसा लगता है कि यह 10^11प्रति वर्ष इस फ़ंक्शन के कॉल के बारे में चल सकता है, जिसका अर्थ है कि हम 10^1189वर्षों के रनटाइम को देख रहे हैं ।

मारबेलस बोर्ड की आगे की व्याख्या

00@0
--/\=0
\\@0&0

00एक भाषा शाब्दिक (या एक संगमरमर) है, जो हेक्साडेसिमल (इसलिए 0) में दर्शाया गया है। यह संगमरमर नीचे गिरता है --, जो किसी भी संगमरमर को 1 से घटाता है (00 लपेटता है और FF या 255 में दशमलव में बदल जाता है)। अब जिस FF के साथ मार्बल नीचे आता है, \\वह एक कॉलम को दाईं ओर, निचले हिस्से में बंद कर देता है @0। यह एक पोर्टल है और मार्बल को दूसरे @0उपकरण तक पहुंचाता है। वहां, /\डिवाइस पर संगमरमर की भूमि , जो एक अनुलिपित्र है, यह संगमरमर की एक प्रति --अपने बाईं ओर रखती है (यह संगमरमर पोर्टल्स के बीच लूपिंग रखेगा और हर लूप पर अपघटित हो जाएगा) और एक संगमरमर की तुलना करता है। मान शून्य और अगर यह बराबर है और यह सही नहीं करने के लिए धक्का अगर गढ़ संगमरमर गिर जाता है। यदि संगमरमर का मान 0 है, तो यह भूमि पर है=0 इसके दाईं ओर।=0&0, एक सिंक्रोनाइज़र, जिसे मैं आगे समझाऊंगा, बाद में।

सब सब में, यह सिर्फ एक लूप में 0 मान संगमरमर के साथ शुरू होता है और इसे तब तक घटाता है जब तक कि यह फिर से 0 तक नहीं पहुंचता है, फिर यह इस 0 मूल्य के संगमरमर को एक सिंक्रोनाइज़र में डालता है और एक ही समय में लूपिंग करता है।

}0@1
&0/\>0!!
--
@1

}0एक इनपुट डिवाइस है, प्रारंभ में nth (बेस 0) कमांड लाइन इनपुट है जब प्रोग्राम को कॉल करना प्रत्येक }nडिवाइस में रखा जाता है। इसलिए यदि आप इस प्रोग्राम को कमांड लाइन इनपुट 2 के साथ कहते हैं, तो 02 मूल्य का संगमरमर इसे बदल देगा }0। यह संगमरमर तब &0डिवाइस में गिर जाता है, एक और सिंक्रोनाइजर, &nसिंक्रोनाइजर्स तब तक मार्बल पकड़ते हैं , जब तक कि अन्य सभी संगत &nफाइल नहीं हो जाती। मार्बल तब पहले से बताए गए लूप की तरह बहुत कम हो जाता है, टेलीपोर्ट और डुप्लिकेट हो जाता है। सही प्रति फिर शून्य के साथ असमानता के लिए जाँच की जाती है ( >0) यदि यह 0 नहीं है, तो यह गिर जाता है। यदि यह 0 है, तो इसे दाईं ओर और जमीन पर धकेल दिया जाता है !!, जो बोर्ड को समाप्त कर देता है।

ठीक है, अब तक हमारे पास एक लूप है जो लगातार 255 से 0 से नीचे गिना जाता है और एक और, समान लूप (कमांड लाइन इनपुट द्वारा खिलाया गया) हर बार हिट होने पर चलता है 0. जब यह दूसरा लूप n बार चला गया हो (अधिकतम 256 ) कार्यक्रम समाप्त हो गया। इसलिए यह लूप का अधिकतम 65536 रन है। ब्रह्मांड को रेखांकित करने के लिए लगभग पर्याप्त नहीं है।

}0
--@2
@2/\=0MB

यह परिचित दिखना शुरू कर देना चाहिए, इनपुट एक बार डिक्रिप्ट हो जाता है, फिर यह मान घूम जाता है और कॉपी हो जाता है (ध्यान दें कि संगमरमर केवल एक बार डिक्रिप्ट हो जाता है, लूप के प्रत्येक रन पर नहीं)। यह तब 0 के लिए समानता के लिए जाँच की जाती है और यदि यह शून्य भूमि पर नहीं है MB। यह मारबेलस में एक फ़ंक्शन है, प्रत्येक फ़ाइल में कई बोर्ड हो सकते हैं और प्रत्येक बोर्ड एक फ़ंक्शन है, प्रत्येक फ़ंक्शन को ग्रिड द्वारा पूर्ववर्ती नाम दिया जाना है :[name]। फ़ाइल में पहले फ़ंक्शन को छोड़कर प्रत्येक फ़ंक्शन, जिसमें एक मानक नाम है: एमबी। तो यह लूप लगातार मुख्य बोर्ड को फिर से उस मूल्य के साथ कहता है n - 1जहां n तेह मान है जिसके साथ इस फ़ंक्शन का उदाहरण कहा जाता है।

तो क्यों n*512?

अच्छा, पहला लूप 4 टिक्स (और 256 बार) में चलता है और दूसरा लूप बोर्ड समाप्त होने से पहले n बार चलता है। इसका मतलब है कि बोर्ड लगभग n*4*256टिक्स के लिए चलता है । अंतिम लूप (जो पुनरावर्ती फ़ंक्शन कॉलिंग करता है) बैक्टीरिया है और 2 टिक्स में चलता है, जिसका अर्थ है कि यह फ़ंक्शन n*4*256/2 = n*512बार कॉल करने का प्रबंधन करता है।

आपने जिन प्रतीकों का उल्लेख नहीं किया है, वे क्या हैं?

\/ एक कचरा बिन है, जो बोर्ड से मार्बल्स को हटाता है, यह सुनिश्चित करता है कि डिस्कनेक्ट किए गए मार्बल्स अन्य मार्बल्स के साथ हस्तक्षेप नहीं करते हैं जो एक राउंड लूप कर रहे हैं और प्रोग्राम को समाप्त होने से रोकते हैं।

बोनस

चूँकि मार्बल बोर्ड के निचले भाग से नीचे गिरते हैं, इसलिए STDOUT को आउटपुट मिलता है, यह प्रोग्राम ASCII वर्णों के ढेर को प्रिंट करता है जबकि यह चलता है।


2
महान व्याख्या, धन्यवाद!
बीटा डेके

2
वाह, यह एक शानदार विचार है! मारबुलस भाषा बहुत मजेदार है!
रबिक

2
+1 बस वही जो मैं देखना चाहता था। BrainFuck की तुलना में एक पागल भाषा :) वहाँ ट्यूटोरियल और इसके बारे में अधिक जानकारी के साथ एक वेबसाइट है? (शीर्षक लिंक से लगता है कि आपके उत्तर की तुलना में कम डॉक्टर हैं)
सिल्वेस्टर

2
@ सिल्वेस्टर, मुझे खुशी है कि आप इसे पसंद करते हैं, मारबेलस वर्तमान में अभी भी विकास में है, लेकिन हम निकट भविष्य में इसे और अधिक स्थिर स्थिति में रखने की उम्मीद करते हैं, जिस पर बिंदु ट्यूटोरियल, अधिक व्यापक प्रलेखन, मानक पुस्तकालय और उम्मीद है कि एक ऑनलाइन दुभाषिया होगा का पालन करें।
ओवरएक्टर

21

पर्ल, 66 58 वर्ण

sub A{($m,$n)=@_;$m?A($m-1,$n?A($m,$n-1):1):$n+1;}A(9,9);

उपरोक्त एकरमैन-पेटर फ़ंक्शन का कार्यान्वयन है । मुझे नहीं पता कि ए (9,9) कितना बड़ा है, लेकिन मुझे पूरा यकीन है कि मूल्यांकन के लिए काफी समय लगेगा।


5
+1 ... मैं एक निर्मित एकरमैन फ़ंक्शन के साथ एक भाषा खोजने की कोशिश कर रहा था, लेकिन मेरे धैर्य से बाहर निकलने से पहले ऐसा करने में विफल रहा। : डी
मार्टिन एंडर

3
$n?A($m-1,A($m,$n-1)):A($m-1,1)टर्नरी ऑपरेटर में धक्का देकर एक आसान 8-चार बचत करता है।
पीटर टेलर

3
मुझे पूरा यकीन है कि ए (9,9) में अंकों की संख्या घन प्लैंक लंबाई में मापा जाने योग्य ब्रह्मांड की मात्रा से बड़ी है।
कास्परड

6
@kasperd यह एक बहुत बड़ी समझ है। अवलोकनीय ब्रह्मांड का आयतन केवल 10 ^ 184 प्लैंक संस्करणों के क्रम पर है। तुलना करके, ए (4,4) में अंकों की संख्या का वर्णन करने वाली संख्या में 10 ^ 19700 अंक जैसे कुछ हैं, जो ए (9,9) की तुलना में असंगत रूप से छोटे हैं।
user19057

3
@ user19057 ऐसा लगता है कि कैस्परर्ड के दावे को "बड़े पैमाने पर समझने वाला" कहा जाता है। : पी
निकु स्तिर्का

20

MATLAB, 58 52 वर्ण

हमें कम से कम एक परिमित-सटीक अंकगणित समाधान की आवश्यकता है, इसलिए:

y=ones(1,999);while y*y',y=mod(y+1,primes(7910));end

x = वाले (1,999); y = x; जबकि कोई (y), y = mod (y + x, primes (7910)); अंत

( 6 चरों पर दस्तक देने के लिए @ डेनिसजेरुद्दीन को धन्यवाद )

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


+1 मुझे यह देखने में थोड़ी देर लगी कि आप वहां क्या कर रहे हैं। अच्छा!
फिक्स्ड प्वाइंट

+1 CRT, है ना?
निर्दोष

अच्छा, मुझे लगता है कि कुछ वर्णों को बचाया जा सकता है, जैसे: y = वाले (1,999); जबकि y * y ', y = mod (y + 1, primes (7910)); अंत
डेनिस जहरुद्दीन

@ डेनिसजेरुद्दीन: शानदार छोटा। मैं अपडेट करूंगा।
COTO

हालांकि यह अब भी एक ही समाधान नहीं है, यह अभी भी काफी समान होना चाहिए, और फिर से थोड़ा छोटा होना चाहिए:p=1:9e9;y=p;while+y*y',y=mod(y+1,p),end
डेनिस जहरुद्दीन

19

गणितज्ञ, 25 19 बाइट्स

समय से पहले अयोग्य घोषित किए जाने से पहले यह समाधान पोस्ट किया गया था।

While[TimeUsed[]<10^10^5]

TimeUsed[]सत्र शुरू होने के कुछ सेकंड बाद, और गणितज्ञ सटीक-सटीक प्रकारों का उपयोग करता है। एक वर्ष में कुछ 10 7 सेकंड होते हैं , इसलिए 10 10000 सेकंड की प्रतीक्षा पर्याप्त होनी चाहिए।

छोटा / सरल (/ वैध) विकल्प:

For[i=0,++i<9^9^9,]

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

तकनीकी रूप से, दोनों समाधानों में, मैं बहुत कम सीमा का उपयोग कर सकता था क्योंकि समस्या न्यूनतम प्रोसेसर गति को निर्दिष्ट नहीं करती है।


इसे प्यार करना! इस जवाब ने मुझे वास्तव में मेरे चेहरे पर एक बड़ी मुस्कान के साथ जोर से हंस दिया।
टोड लेहमन

1
क्षमा करें, रचनात्मकता के लिए, मुझे समय आधारित समाधान (जैसे आपके पहले वाले) को काटना पड़ा। कृपया मुझसे नफरत मत करो। :)
kb_sou

5
@kbsou ठीक है, मैंने इसे अपने दूसरे के साथ पीटा है, इसलिए मुझे वास्तव में परवाह नहीं है। लेकिन अन्यथा नियम में बदलाव के लिए जवाब को अयोग्य घोषित करना हालांकि शांत नहीं है। ;)
मार्टिन एंडर

1
क्या गणितज्ञ वास्तव में इतना धीमा है, कि कंप्यूटिंग में वर्षों 9^9^9से अधिक समय लगता है 10^1000? मेरा अनुमान है कि 9^9^9मेरे 1.3GHz U7300 का उपयोग करने पर कंप्यूटिंग को bc6 महीने से कम समय लगेगा। (समय की गणना करने के extrapolating के आधार पर 9^200000और 9^400000।)
kasperd

2
@ArtOfCode Mathematica मनमानी-सटीक प्रकारों का उपयोग करता है इसलिए यह वास्तव में सही मूल्य निर्धारित करने का प्रयास करेगा।
मार्टिन एंडर

16

पायथन 3 - 49

यह कुछ उपयोगी करता है: ग्रेगरी-लिबनीज अनंत श्रृंखला का उपयोग करके पाई को अभूतपूर्व सटीकता के लिए गणना करता है।

बस अगर आप सोच रहे थे, तो यह कार्यक्रम 10**10**10**2.004302604952323कई बार समाप्त हो जाता है।

sum([4/(i*2+1)*-1**i for i in range(1e99**1e99)])

मनमाना परिशुद्धता: 78

from decimal import*
sum([Decimal(4/(i*2+1)*-1**i)for i in range(1e99**1e99)])

छवि स्रोत

टर्मिनल सांस

भारी गणना होने के कारण, 1e99**1e99पुनरावृत्तियों में अभी 1e99**1e99वर्षों का समय लगता है । अब, (1e99**1e99)-1e1000मुश्किल से कोई फर्क पड़ता है। इसका मतलब है कि यह कार्यक्रम हमारे ब्रह्मांड की मृत्यु से कहीं अधिक समय तक चलेगा।

पुनर्जन्म

अब, वैज्ञानिकों का प्रस्ताव है कि 10**10**56 yearsक्वांटम उतार-चढ़ाव या टनलिंग के कारण ब्रह्मांड का पुनर्जन्म होगा। इसलिए यदि प्रत्येक ब्रह्मांड बिल्कुल समान है, तो मेरा कार्यक्रम कितने ब्रह्मांड में रहेगा?

(1e99**1e99)/(1e10+1e1000+10**10**56)=1e9701

यह मानते हुए कि ब्रह्मांड हमेशा 1e10+1e1000वर्षों तक जीवित रहेगा और फिर 10**10**56'रिबूट' होने में वर्षों लगेंगे , मेरा कार्यक्रम 1e9701ब्रह्मांड के माध्यम से जीवित रहेगा । यह, निश्चित रूप से, यह है कि unobtainium बिग बैंग के माध्यम से रह सकते हैं।


3
एक बार यह सीमा समाप्त होने पर @Philipp पर पहुँच जाता है। हाँ, यह समाप्त हो जाता है।
मलाकी

1
1000**1000है 1e3000, नहीं 1e2000
कॉर्न्स्टल

1
@Cornstalks धन्यवाद, मेरे पास इतना अच्छा कैलकुलेटर नहीं था कि मैं यह पता लगा सकूं कि मैंने इस तथ्य के आधार पर अनुमान लगाया है 100**100=1E200
बीटा डेके

1
@ BetaDecay: मैं एक ऑनलाइन कैलकुलेटर के रूप में वुल्फराम का सुझाव दे सकता हूं । यदि आपने कभी इसका उपयोग नहीं किया है, तो यह बहुत बढ़िया है!
कॉर्न्स्टल

2
@anyoneinterested या 1000 ^ 1000 = (10 ^ 3) ^ 1000 = (10 * 10 * 10) * (10 * 10 * 10) * ... * (10 * 10 * 10) [1000 बार] = 10 ^ 3000
इज़ारेत्युयोपि

12

अजगर 59 (ज्यादातर समय काम करता है)

मैं विरोध नहीं कर सका

from random import*
while sum(random()for i in range(99)):0

हालांकि यह सच है कि यह सैद्धांतिक रूप से एक मिलीसेकंड के तहत समाप्त हो सकता है, औसत रनटाइम 10^400ब्रह्मांड के निर्दिष्ट जीवनकाल के दौरान अच्छी तरह से है। इसके लिए 17 अक्षर या उससे नीचे उतरने के लिए @BetaDecay, @undergroundmonorail, और @DaboRoss को धन्यवाद।


71 के लिए नीचे प्राप्त करने के लिए आप की जगह ले सकता continueसाथpass
बीटा क्षय

नाइस पकड़ @BetaDecay
KSab

3
मुझे लगता है कि चूंकि प्रश्न अपेक्षित समय के लिए पूछ रहा है, इसलिए यह कोई समस्या नहीं है कि यह जल्दी समाप्त हो जाए। बड़ा मुद्दा यह है कि इसे समाप्त करने के लिए बिल्कुल भी साबित नहीं किया जा सकता है।
user19057

4
@ user19057 यह मानते हुए कि केसाब ने क्या कहा, अपेक्षित समय चल रहा है और कार्यक्रम 100% संभावना के साथ समाप्त हो गया है। बेशक यादृच्छिक मॉड्यूल वास्तव में एक PRNG का उपयोग करता है, जो चक्रीय है, इसलिए सबसे अधिक संभावना है कि यह कभी भी समाप्त नहीं होगा।
जेरोम बॉम

1
मुझे लगता है कि आप '0' के साथ 'पास' की जगह 3 अक्षर काट सकते हैं।
दिनांक

8

जे - 5 चार्ट, मुझे लगता है

ध्यान दें कि निम्नलिखित सभी मनमाने ढंग से सटीक अंकगणित में हैं, क्योंकि संख्या 9 हमेशा इसके xबगल में थोड़ी सी होती है।

में सात वर्ण, हमारे पास !^:!!9x, चल रहा है की तरह थोड़े है जो

n = 9!
for i in range(n!):
    n = n!

मनमाना सटीक अंकगणित में। यह निश्चित रूप से सीमा से अधिक है क्योंकि सिंथेटिका ने ऐसा कहा था , इसलिए हमारे पास एक ऊपरी सीमा है।

में छह वर्ण, हम भी लिख सकते हैं ^/i.9x, जिसमें से प्रत्येक मध्यवर्ती परिणाम की गणना करता है 0 ^ 1 ^ 2 ^ 3 ^ 4 ^ 5 ^ 6 ^ 7 ^ 8। वोल्फ्राम | अल्फा कहते हैं 2^3^4^5^6^7^8, लगभग है 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 10 ^ 6.65185, जो शायद निरीक्षण को भी साफ करता है।

हमारे पास पांच चार भी हैं !!!9x, जो सिर्फ ((9!)!) है। डब्ल्यू | ए का कहना है कि यह 10 ^ 10 ^ 10 ^ 6.2695अभी भी काफी बड़ा होना चाहिए ... यह 1.6097e1859933-ish अंकों की तरह है , जो 3.154e1016कि ब्रह्मांड में नैनोसेकंड की तुलना में निश्चित रूप से बड़ा है, लेकिन मैं मानता हूं कि मुझे नहीं पता कि कोई कैसे समझ सकता है इन चीजों के असली रनटाइम्स।

अकेले मुद्रण को ब्रह्मांड की तुलना में लंबे समय तक चलने के लिए पर्याप्त समय लेना चाहिए, हालांकि, यह ठीक होना चाहिए।


7

C, 63 56 वर्ण

f(x,y){return x?f(x-1,y?f(x,y-1):1):y+1;}main(){f(9,9);}

यह विल्हेम नाम के एक व्यक्ति के विचार पर आधारित है। मेरा एकमात्र योगदान इस संक्षिप्त (और अपठनीय) टुकड़े के लिए कोड को संघनित करना है।

यह साबित करते हुए कि यह समाप्त हो गया है प्रेरण द्वारा किया जाता है।

  • यदि x 0 है, तो यह तुरंत समाप्त हो जाता है।
  • यदि यह x-1 और किसी y के लिए समाप्त हो जाता है, तो यह x के लिए भी समाप्त हो जाता है, इसे ही इंडक्शन द्वारा दिखाया जा सकता है।

प्रेरण द्वारा प्रेरण कदम साबित करना:

  • यदि y 0 है, तो x-1 के साथ केवल एक पुनरावर्ती कॉल है, जो प्रेरण धारणा द्वारा समाप्त होता है।
  • यदि f (x, y-1) समाप्त हो जाता है तो f (x, y) भी समाप्त हो जाता है क्योंकि f का अंतरतम कॉल बिल्कुल f (x, y-1) है और सबसे बाहरी कॉल इंडक्शन हाइपरसिस के अनुसार समाप्त हो जाता है।

अपेक्षित रनिंग टाइम A (9,9) / 11837 सेकंड है। यह संख्या अवलोकनीय ब्रह्मांड में क्वार्क की संख्या से अधिक अंक है।


(Ab) प्रीप्रोसेसर का उपयोग करें और m = main, r = return, और z = 99999 को परिभाषित करें, फिर अपने प्रोग्राम को फिर से लिखें, f (x, y) {rx? F (x-1, y? F? (X, y-) 1): 1): y + 1;} m () {f (z, z);} जो आश्चर्यजनक रूप से लंबे समय ले जाएगा :-)
ChuckCottrill

5
@ChuckCottrill यदि नियमों ने उन कार्यक्रमों की अनुमति दी, जिनके लिए विशिष्ट प्रीप्रोसेसर मैक्रोज़ की आवश्यकता होती है, और जो प्रोग्राम की लंबाई की ओर नहीं आते हैं, तो किसी भी कार्य को एक वर्ण में हल किया जा सकता है।
कैस्परर्ड

6

मतलाब ( 10 8 वर्ण)

1:9e1016

IMHO, अधिकांश प्रविष्टियाँ बड़ी, जटिल चीज़ों की गणना करके बहुत अधिक प्रयास कर रही हैं। यह कोड केवल 9x10 1016 की double गिनती 1 से शुरू करेगा, जो 7.2x10 ^ 1017 बाइट लेता है । 21 जीबी / एस या 6.63x10 ^ 17 बाइट्स / वर्ष की अधिकतम मेमोरी बैंडविड्थ के साथ एक आधुनिक सीपीयू पर , यह सरणी को इनिशियलाइज़ करने में कम से कम 1.09x10 1000 साल का समय लेगा , अकेले ही इसे प्रिंट करने की कोशिश करें क्योंकि मैं परेशान नहीं हुआ था एक अनुगामी अर्धविराम के साथ उत्पादन को दबाने। (;


पुराना समाधान

nan(3e508)

वैकल्पिक रूप से

inf(3e508)

यह कोड केवल x 8-बाइट डबल्स या बाइट्स के NaNs / infinities का एक वर्ग मैट्रिक्स बना देगा ।3e5083e508 = 9e10167.2e1017


1
वह क्या है? 1016? जो कि 9999 होना चाहिए! (या मैंने कुछ गलत समझा?)
मेगा मैन

@MegaMan प्रॉब्लम प्रॉम्प्ट 10 ^ 1000 वर्षों के रनटाइम लोअर बाउंड के लिए कहता है। यह किया जा रहा है गोल्फ, मैं बेकार हो सकता है और गणना करने के लिए नहीं करना चाहता था भी बहुत अधिक समय हो, तो मैं यह जितनी जल्दी हो सके सीमा तक पहुंचने के बाद बंद करने के लिए प्राप्त करने की कोशिश। :)
निकु स्तिर्का

आह, ठीक है, इस नियम को नहीं जानता था
मेगा मैन

5

पर्ल, 16 वर्ण

/$_^/for'.*'x1e9

यह एक बार दोहराए जाने वाले एक स्ट्रिंग का निर्माण करता है। * "एक अरब बार, फिर इसे रेक्सक्स मैच में सुई और हिस्टैक दोनों के रूप में उपयोग करता है। यह बदले में, रेगेक्स इंजन को स्ट्रिंग के दो बिलियन वर्णों के हर संभव विभाजन का प्रयास करने का कारण बनता है। विकिपीडिया के इस सूत्र के अनुसार , लगभग 10 35218 ऐसे विभाजन हैं।

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

/$_^/for'.*'x~0

(मैंने इसका परीक्षण नहीं किया है, लेकिन मुझे लगता है कि यह 32-बिट पर्ल के साथ कम से कम 6 जीबी रैम के साथ 64-बिट मशीन पर बनाया जा सकता है।)

टिप्पणियाँ:

  • x स्ट्रिंग रिपीट ऑपरेटर है।
  • forएक वास्तविक पाश नहीं है; इसका उपयोग केवल एक चरित्र को बचाने के लिए किया जाता है (तुलना में $_=".*"x1e9;/$_^/)।
  • ^रेगेक्स में फाइनल यह सुनिश्चित करता है कि केवल खाली स्ट्रिंग मेल खा सकती है; चूंकि रेगेक्स क्वांटिफायर डिफ़ॉल्ट रूप से लालची होते हैं, यह आखिरी चीज है जो इंजन कोशिश करेगा।
  • मूल्यों के लिए मेरे कंप्यूटर पर बेंचमार्क (1..13) सुझाव देते हैं कि चलने का समय वास्तव में ओ (एक्सप (एन)) है, जो विकिपीडिया फॉर्मूला में ओ (एक्सप (sqrt (n))) से भी अधिक है।

4

जे (12)

(!^:(!!9))9x

यह पायथन में क्या आता है ( !काम करता है):

a = 9 
for i in range((9!)!):
    a = a!

संपादित करें:

ठीक है, कार्यक्रम 2 × 10^-1858926को आवश्यक समय के भीतर पूरा करने के लिए, प्रति सेकंड , प्रति सेकंड , ले सकते हैं । युक्ति: यह पहले चक्र के लिए भी काम नहीं करेगा, पिछले एक को कभी ध्यान न दें;)।

इसके अलावा: इस कार्यक्रम को ब्रह्मांड में एन्ट्रापी की तुलना में अधिक मेमोरी की आवश्यकता हो सकती है ...


3
"ब्रह्मांड में एन्ट्रापी की तुलना में अधिक मेमोरी की आवश्यकता हो सकती है" - आप उस पर कटौती कर सकते हैं xrange();)
स्टीफन मेजेवस्की

1
इसके अलावा, !पायथन में काम नहीं करता है। आप की जरूरत है import mathऔर math.factorial()
डेव्यूलेस 1

4

C # 217

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

class P{
static void Main(){for(int i=0;i<100;i++){for(int j=0;j<100;j++){Console.WriteLine(ack(i,j));}}}
static int ack(int m,int n){if (m==0) return n+1;if (n ==0) return ack(m-1,1);return ack(m-1,ack(m,n-1));}
}

आप ackफ़ंक्शन को एकल-वर्ण नाम जैसे फ़ंक्शन का नाम देकर 10 बाइट्स बचा सकते हैं a
पिपरी

4

कोड गोल्फ में पहला प्रयास लेकिन यहाँ जाता है।

VBA - 57 45

x=0
do
if rnd()*rnd()<>0 then x=0
x=x+1
while 1=1

तो X एक से बढ़ेगा यदि 1 में 2 ^ 128 ईवेंट घटित होता है और यदि ऐसा नहीं होता है, तो रीसेट करें। जब यह घटना पंक्ति में 2 ^ 64 + 1 बार होती है तो कोड समाप्त हो जाता है। मुझे नहीं पता कि समय की गणना कैसे शुरू करें लेकिन मुझे लगता है कि यह बहुत बड़ा है।

संपादित करें: मैंने गणित का काम किया और प्रत्येक लूप में ऐसा होने की संभावना 2 में से 1 ^ 128 ^ (1 + 2 ^ 64) है जो लगभग 20000 अंकों की लंबी है। 1000000 लूप्स / सेकंड (पतली हवा की संख्या से बाहर बॉलपार्क) और 30000000 s / yr मानकर कि 3 * 10 ^ 13 चक्र प्रति वर्ष समय 10 ^ 1000 वर्ष बचे 3 * 10 ^ 1013 चक्र है, इसलिए यह लगभग 20 गुना होने की संभावना है ब्रह्मांड में शेष समय। मुझे खुशी है कि मेरा गणित मेरे अंतर्ज्ञान का समर्थन करता है।


मुझे लगता है कि अंतिम पंक्ति While x=1सही होनी चाहिए ? (अन्यथा इसका एक अनंत लूप है)। इसके अलावा, आप 12 वर्ण बंद दाढ़ी सकते हैं यदि आप स्थानापन्न Dim x As Doubleके साथ x=0(VBA जब तक आपके द्वारा निर्दिष्ट चर घोषित करने के लिए की आवश्यकता नहीं है Option Explicit)
kb_sou

मैं इसे अनंत लूप के रूप में नहीं देखता हूं क्योंकि यह एक्स ओवरफ्लो होने पर टूट जाता है जो अंततः है।
मायल हॉर्ने

यह निश्चित रूप से x = 1 के साथ काम नहीं करता है क्योंकि यह आम तौर पर लूप को चलने से रोकता है।
माइल हॉर्ने

अगर इस तरह से टूटने से लूप "नो इनफिनिट लूप्स" मापदंड को पूरा नहीं करता है तो WHILE 1 = 1 ISNUMERIC (X) में बदल सकता है।
माइल हॉर्ने

4

सी, 30 अक्षर

main(i){++i&&main(i)+main(i);}

दो प्रशंसाओं को अतिप्रवाह और 32-बिट इन्टस मानते हुए, यह लगभग 2 2 32 फ़ंक्शन कॉल के लिए चलेगा , जो ब्रह्मांड को समाप्त होने के लिए बहुत समय होना चाहिए।


आप तब से बहुत पहले ढेर से बाहर निकलेंगे, हालाँकि।
Sparr

1
@ नियमों में से एक अनंत ढेर और ढेर के आकार को मानने के लिए है।
स्कैप

3

GolfScript, 13 वर्ण

0{).`,9.?<}do

इस कार्यक्रम सिर्फ 10 0 से ऊपर गिना जाता है 9 9 -1 = 10 387,420,488 । यह मानते हुए कि आशावादी रूप से, कंप्यूटर 100 गीगाहर्ट्ज पर चलता है और एक चक्र में कार्यक्रम के प्रत्येक पुनरावृत्ति को निष्पादित कर सकता है, कार्यक्रम 10 9 9 seconds12 सेकंड के लिए चलेगा , या लगभग 3 × 10 9 9 = 20 = 3% 10 387420469 वर्षों।

कार्यक्रम का परीक्षण करने के लिए, आप इसे 9एक के साथ बदल सकते हैं 2, जो इसे 10 2 2 program1 = 10 3 = 1000 पर रोक देगा । ( वसीयत के 3बजाय 2इसे 10 3 3 = 1 = 10 26 पर रोक देगा , जो यहां तक ​​कि ऊपर की आशावादी मान्यताओं के साथ, यह कम से कम कुछ मिलियन वर्षों तक नहीं पहुंचेगा।)



3

हास्केल, २३

main=interact$take$2^30

इस कार्यक्रम से 1073741824 अक्षर पढ़ने के बाद समाप्त हो गया stdin। यदि यह बिना किसी डेटा को पाइप किए चलाया जाता हैstdin , तो आपको अपने कीबोर्ड पर इस वर्ण को टाइप करना होगा। मान लें कि आपके कीबोर्ड में 105 कीज़ हैं, प्रत्येक को 100k मेकेनिकल साइकल के लिए रेट किया गया है और नॉन-डेड कीस्ट्रोक्स उत्पन्न करने के लिए प्रोग्राम किया गया है, ऑटोरेस्पेट बंद है, और आपका कीबोर्ड सॉकेट 100 कनेक्शन साइकल की अनुमति देता है, यह प्रति कंप्यूटर कीस्टेक्टैक्स की अधिकतम संख्या 1050000000 है, जो है कार्यक्रम को समाप्त करने के लिए पर्याप्त नहीं है।

इसलिए, कार्यक्रम केवल तभी समाप्त होगा जब बेहतर हार्डवेयर चक्रों की संख्या के संदर्भ में उपलब्ध हो जाता है, जो प्रभावी रूप से इस चल रहे ब्रह्मांड में कभी नहीं होता है। हो सकता है कि अगली बार, जब गुणवत्ता में मात्रा से अधिक प्राथमिकता हो। तब तक, यह कार्यक्रम सिद्धांत रूप में समाप्त हो जाता है, लेकिन व्यवहार में नहीं।


यदि आप जाते हैं तो क्या आप हॉट-स्वैप कीबोर्ड करते हैं?
थॉमस

यह कीबोर्ड सॉकेट के 100 कनेक्शन चक्रों द्वारा कवर किया गया है।
theSpanishInquisition

लेकिन समस्या यह है की बात यह है कि कार्यक्रम है करता समाप्त कहीं ब्रह्मांड की गर्मी मृत्यु के बाद,। यह कार्यक्रम संभवतः कभी समाप्त नहीं हो सकता है; एक बार एन्ट्रापी काफी अधिक हो जाने के बाद, आपके पास प्लग इन करने के लिए एक और कीबोर्ड कभी नहीं होगा।
समाप्त करें

1
मैं अभी भी यकीन नहीं कर रहा हूँ। यदि आप प्रोग्राम को दूरस्थ रूप से (या VM में) चलाते हैं, तो आप किसी एकल कंप्यूटर की हार्डवेयर क्षमताओं द्वारा सीमित नहीं हैं, और 1 बिलियन स्ट्रोक वास्तव में उतना नहीं है। इसके अलावा, समस्या कहती है कि कंप्यूटर unobtainium से बना है, और इसलिए कीबोर्ड भी होना चाहिए, इसलिए, यह 2 ^ 30 कीस्ट्रोक्स को संभाल सकता है ...
थॉमस

3

~ एटीएच, ५६

में काल्पनिक भाषा ~ एथलीट :

import universe U;
~ATH(U) {
} EXECUTE(NULL);
THIS.DIE()

~ एटीएच साथ काम करने के लिए एक अपर्याप्त भाषा है। इसका तर्क कुछ और नहीं बल्कि अनंत छोरों, या सबसे अच्छे से बना है, प्रभावी ढंग से अंतर्निर्मित निर्माण के छोरों।

कितने ~ ATH कोडर आयात परिमाण का निर्माण करते हैं और छोरों को उनके जीवन काल में बांधते हैं। उदाहरण के लिए, मुख्य लूप यहां ब्रह्मांड की मृत्यु पर समाप्त हो जाएगा, यू लेबल। इस तरह आपको केवल हमेशा के लिए खत्म होने के लिए अरबों साल इंतजार करना होगा।

मैं सीमा रेखा के उल्लंघन के लिए माफी माँगता हूँ; मैंने सोचा कि यह भी पारित करने के लिए प्रासंगिक था।

यदि किसी को वास्तव में इससे बहुत खुशी हुई, तो अधिक विवरण: (1) , (2) , (3) , (4)


2

रूबी (34)

9 के लिए लाइन ([0]*9).permutation.each{print}में लगभग 2.47 सेकंड लगते हैं! मेरी मशीन पर प्रिंट करता है, जबकि लाइन ([0]*10).permutation.each{print}10 के लिए लगभग 24.7 सेकंड लेती है! प्रिंट करता है, इसलिए मुझे लगता है कि मैं यहां एक्सट्रपलेशन कर सकता हूं और गणना कर सकता हूं कि (24.7/10!)*470! seconds in years6.87 * 10 ^ 1040 है, जो निम्न समय का होना चाहिए:

([0]*470).permutation.each{print}

2

जावास्क्रिप्ट 68 62 वर्ण

(function a(m,n){return m==0?n+1:a(m-1,n==0?1:a(m,n-1))})(5,1)

यह एकरमन-फंक्शन का उपयोग करता है जिसे लिखा जा सकता है

function ackermann(a, b) {
  if (a == 0) return b + 1;
  if (b == 0) return ackermann(a-1, 1);
  else return ackermann(a-1, ackermann(a, b-1));
}

इसके रनटाइम समय में तेजी से वृद्धि होती है और गणना करने में बहुत लंबा समय लगता है। भले ही यह अंग्रेजी नहीं है, यहां आप इसके रिटर्न वैल्यू का अवलोकन कर सकते हैं। तालिका के अनुसार जो ackermann(5,1)समान 2↑↑(65533)-3है, आप जानते हैं, बहुत बड़ा।


2
यह कुछ उसी आशावाद से लाभ उठा सकता है जैसा कि पहले पर्ल एक्कर्मन फ़ंक्शन कार्यान्वयन में था।
पीटर टेलर

मैंने पर्ल समाधान की अनदेखी की होगी। यह बात बताने के लिए धन्यवाद।
हेनजे

इसके बजाय n==0?X:Y, आप हमेशा कर सकते हैंn?Y:X
साइओस

2

Befunge '93 - 40 बाइट्स

(20x2 कार्यक्रम)

v<<<<<<<<<<<<<<<<<<<
>??????????????????@

यह कार्यक्रम इसे देरी देने के लिए यादृच्छिक संख्याओं पर निर्भर करता है। चूंकि Befunge दुभाषिए काफी धीमा हैं, इसलिए इस कार्यक्रम को बिल फिट होना चाहिए। और अगर ऐसा नहीं होता है, तो हम हमेशा क्षैतिज रूप से इसका विस्तार कर सकते हैं। Im बिल्कुल निश्चित नहीं है कि इस कार्यक्रम के अपेक्षित समय की गणना के बारे में कैसे जाना जाए, लेकिन मुझे पता है कि प्रत्येक? या तो शुरू करने या अपनी क्षैतिज स्थिति को बदलने की 50/50 संभावना है। 18 तक? मुझे लगता है कि यह (18 ^ 2) की तर्ज पर कुछ होना चाहिए !, जो Google कैलकुलेटर कहता है कि "इन्फिनिटी" है

EDIT: वूप्स मैंने दूसरे बेफुन्ज के जवाब पर ध्यान नहीं दिया, यह मेरी पहली पोस्ट है। माफ़ करना।


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

2

एपीएल, १०

मुझे नहीं लगता कि यह एक वैध उत्तर है (क्योंकि यह गैर-नियतात्मक है), लेकिन फिर भी ......

{?⍨1e9}⍣≡1

यह प्रोग्राम 1e9 संख्याओं ( ?⍨1e9) का एक यादृच्छिक क्रमपरिवर्तन की गणना करता है और तब तक दोहराता है जब तक कि लगातार दो आउटपुट बराबर न हों (⍣≡ )

तो, हर बार एक क्रमचय की गणना की जाती है, इसमें 1000000000 में 1 होता है! समाप्त करने का मौका। और 1000000000! कम से कम 10 10 8 है

एक क्रमचय की गणना करने में लगने वाला समय 1000000000 की व्यापकता से अप्रासंगिक है। लेकिन कुछ परीक्षण यह दिखाते हैंO(n) और एक्सट्रपलेटिंग लगभग 30 सेकंड देता है।

हालाँकि, मेरे दुभाषिया ने रैंडम फंक्शन के इनपुट्स को 31 31 -1 (इसलिए मैंने 1e9 का इस्तेमाल किया) से बड़ा करने से इंकार कर दिया , और 1000000000 नंबरों के परमिट को जेनरेट करते हुए एक वर्कस्पेस को फुल एरर दिया। हालांकि, वैचारिक रूप से यह एक आदर्श एपीएल दुभाषिया के साथ अनंत स्मृति के साथ किया जा सकता है।

यह हमें 64-बिट आर्किटेक्चर मानते हुए कम से कम 10 10 20 तक चलने के समय को 1e9 के स्थान पर 2 63 -1 का उपयोग करने की संभावना की ओर ले जाता है ।

लेकिन रुको, एक आदर्श दुभाषिया में वास्तुकला प्रासंगिक है? नर्क नहीं तो वास्तव में रनिंग टाइम पर कोई ऊपरी सीमा नहीं है !!


2

आर, 45 बाइट्स

(f=function(x)if(x)f(x-1)+f(x-1)else 0)(9999)

यह एक पुराना धागा है, लेकिन मुझे कोई आर जवाब नहीं दिखता है, और हम ऐसा नहीं कर सकते हैं!

मेरे लिए रनटाइम 1s था जब x 20 था, 2 ^ 9979 सेकंड के रनटाइम का सुझाव दिया।

यदि आप शून्य को एक के साथ प्रतिस्थापित करते हैं, तो आउटपुट 2 ^ x होगा, लेकिन जैसा कि यह है कि आउटपुट शून्य है जो कुछ भी x था (अतिप्रवाह समस्याओं से बचा जाता है)।


1

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

a=[0];while(a.length<1e4)(function(){var b=0;while(b<a.length){a[b]=(a[b]+1)%9;if(a[b])return;b++}a.push(1)})();alert(a)

कम से कम मेमोरी (शायद आधे मेगाबाइट से कम) के साथ किया जा सकता है लेकिन रुकने में लगभग 10 8,750 साल लगते हैं।

जब तक यह ९ १० -१ तक नहीं पहुंच जाता तब तक थोड़ा-सा आधार ९-बिगइन्टेगर बढ़ाता है ।


1

पायथन 3, 191 बाइट्स

from random import*
r=randint
f=lambda n:2if n<2else f(n-1)
x=9E999
s=x**x
for i in range(f(x)**f(s)):
 while exec(("r(0,f(x**i))+"*int(f(x)))+"r(0,f(x**i))")!=0:
  s=f(x**s)
  print(s)

सबसे पहले, एफ एक पुनरावर्ती फैक्टरियल फ़ंक्शन और अल्ट्रा स्लो है। फिर, अपने आप से 9 * 10 with powed है, जो एक OverflowError जनरेट करता है, लेकिन इस Unwell Computer पर ऐसा नहीं होता है। फॉर-लूप 9E999 को पुन: प्रसारित करता है! ^ (9E999 ^ 9E999)! बार और यह केवल अगले पुनरावृत्ति में जाता है, यदि 9E999! 0 और 9E99 * ^ के बीच में यादृच्छिक यादृच्छिक! सभी 0 हैं और जबकि-लूप s के हर पुनरावृत्ति में (9E999 ^ s) सेट हो जाता है। उह, मैं भूल गया कि s की छपाई में muuuuccchhhh समय लगता है ...
मुझे पता है कि यह सबसे छोटा समाधान नहीं है, लेकिन मुझे लगता है कि यह वास्तव में प्रभावी है। क्या कोई मुझे चलने के समय की गणना करने में मदद कर सकता है?


1

ट्यूरिंग मशीन बट वे वर्से , 167 बाइट्स

0 0 1 1 2 0 0
1 0 1 0 4 0 0
0 1 1 1 2 0 0
1 1 1 1 5 0 0
0 2 1 0 3 0 0
1 2 0 1 1 0 0
0 3 1 1 4 0 0
1 3 0 0 2 0 0
0 4 1 0 0 0 0
1 4 0 1 3 0 0
0 5 1 0 6 0 1
1 5 1 1 2 0 0

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

विकिपीडिया पृष्ठ से 6-राज्य 2-प्रतीक व्यस्त बीवर को चलाना चाहिए ।

7.412×1036534

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.