कोड के दस बाइट्स में सबसे बड़ी संख्या

Question

आपका लक्ष्य कोड के सिर्फ दस वर्णों का उपयोग करके (मानक आउटपुट तक) सबसे बड़ी संख्या को प्रिंट करना है।

• बिल्ट-इन घातांक कार्यों को छोड़कर आप अपनी भाषा की किसी भी सुविधा का उपयोग कर सकते हैं।
  • इसी तरह, आप एक संख्या में प्रवेश करने के लिए वैज्ञानिक संकेतन का उपयोग नहीं कर सकते हैं। (इस प्रकार, नहीं 9e+99।)
• प्रोग्राम को उपयोगकर्ता से किसी भी इनपुट के बिना नंबर प्रिंट करना होगा। इसी तरह, अन्य फ़ाइलों से या वेब से कोई रीडिंग नहीं, और इसी तरह।
• आपके प्रोग्राम को एक ही संख्या की गणना करनी चाहिए और उसे प्रिंट करना होगा। आप एक स्ट्रिंग नहीं प्रिंट कर सकते हैं, न ही आप एक ही अंक को हजारों बार प्रिंट कर सकते हैं।
• आप कुछ भी प्रिंट करने के लिए आवश्यक किसी भी कोड को 10-वर्ण की सीमा से बाहर कर सकते हैं। उदाहरण के लिए, पायथन 2 में जो print xवाक्य रचना का उपयोग करता है , आप अपने कार्यक्रम के लिए अधिकतम 16 वर्णों का उपयोग कर सकते हैं।
• कार्यक्रम वास्तव में आउटपुट में सफल होना चाहिए। यदि दुनिया के सबसे तेज़ कंप्यूटर पर चलने में एक घंटे से अधिक समय लगता है, तो यह अमान्य है।
• उत्पादन किसी भी प्रारूप में हो सकता है (यदि आप प्रिंट कर सकते हैं तो 999, 5e+100, आदि)
• अनंत एक अमूर्त अवधारणा है , संख्या नहीं। तो यह एक मान्य आउटपुट नहीं है।

Comments

क्या आपने इन दोनों को देखा? codegolf.stackexchange.com/questions/185/… codegolf.stackexchange.com/questions/18028/…

— MadTux

"गणना" से आपका क्या तात्पर्य है। इसके अलावा, If it takes longer than an hour to run on any computer in the world, it's invalid.उद्देश्य नहीं है। मैं (सैद्धांतिक रूप से) एक कंप्यूटर का निर्माण कर सकता था जो एक टी-स्टेट को बदलने में एक घंटा लेता है

— user80551

क्या बिट-शिफ्ट की गणना एक घातांक ऑपरेटर के रूप में की जाती है क्योंकि यह बराबर है * 2^x?

— क्लाउडी

तथ्य यह है कि समय सीमा दुनिया के सबसे तेज कंप्यूटर के प्रदर्शन पर निर्भर करती है, जिससे हमारे लिए वैध उत्तरों के सेट को निर्धारित करना असंभव हो जाता है ... मुझे वास्तव में यह पसंद नहीं है

— डेविड जेड

घातांक कार्यों की अनुमति नहीं है, लेकिन एकरमैन फ़ंक्शन की अनुमति है? यह वास्तव में मनमाना लगता है। यह स्पष्ट नहीं है कि एक प्रतीकात्मक हेरफेर को संख्या की "गणना" क्यों माना जाता है।

— वोल्फराम एचएच

Answer 1

वोल्फ्राम भाषा

ack(9!,9!)

ack (9!, 9!) =

आउटपुट एरो नोटेशन में है।

Comments

@KyleKanos इसकी भिन्नता है क्योंकि कोड / प्रोग्राम वेब पर कॉल नहीं कर रहा है। अन्य उदाहरण typescriptlang.org/Playground tryfsharp.org/Learn/getting-started

— एडम स्पाइट

वुल्फ्राम भाषा एक रास्पबेरी पाई का उपयोग करने के लिए उपलब्ध है और इसे वेब एक्सेस की आवश्यकता नहीं है। तो उस नियम का उल्लंघन नहीं है।

— एडम स्पाइट

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

— माइक्रोबियन

ack(99!,9)बहुत, बहुत बड़ा है।

— jimmy23013

अन्य उत्तरों में से एक का कहना है कि एक (4,2) सबसे बड़ा है जो वह एक घंटे में गणना कर सकता है इसलिए मुझे आश्चर्य होगा कि अगर ऐसा हुआ ...

— जैरी जेमियाह

Answer 2

पर्ल,> 1.96835797883262e + 18

time*time

आज शायद सबसे बड़ा जवाब नहीं ...! लेकिन पर्याप्त सहस्राब्दियों की प्रतीक्षा करें और यह होगा!

---

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

कुछ टिप्पणियों को संबोधित करने के लिए, "पर्याप्त सहस्राब्दी," मैं वास्तव में n ¹⁰⁰ साल का मतलब है ।

निष्पक्ष होने के लिए, यदि ब्रह्मांड का बड़ा फ्रीज / हीट डेथ है तो ब्रह्मांड कैसे समाप्त होगा (अनुमानित 10 ~ ¹⁰⁰ वर्ष), "अंतिम" मान ~ 10 ^{214 होगा} , जो निश्चित रूप से कुछ की तुलना में बहुत कम है अन्य प्रतिक्रियाएं (हालांकि, "यादृच्छिक क्वांटम उतार-चढ़ाव या क्वांटम टनलिंग 10 ^{10 56} वर्षों में एक और बिग बैंग पैदा कर सकती है ")। यदि हम अधिक आशावादी दृष्टिकोण (उदाहरण के लिए एक चक्रीय या बहुआयामी मॉडल) लेते हैं, तो समय असीम रूप से चलेगा, और इसलिए किसी दिन किसी ब्रह्मांड में, कुछ उच्च-बिट वास्तुकला पर, उत्तर दूसरों में से कुछ से अधिक होगा।

दूसरी ओर, जैसा कि बताया गया है, timeवास्तव में पूर्णांक / लंबे के आकार तक सीमित है, इसलिए वास्तव में ऐसा कुछ ~0हमेशा की तुलना में एक बड़ी संख्या का उत्पादन करेगा time(अर्थात timeवास्तुकला द्वारा समर्थित अधिकतम )।

यह सबसे गंभीर जवाब नहीं था, लेकिन मुझे आशा है कि आप लोग इसे पसंद करेंगे!

Comments

अपवित्र इसलिए क्योंकि मुझे घटना की तरह

— टिम

timeचारों ओर लपेटो और कुछ बिंदु पर एक छोटी संख्या वापस नहीं होगा ? इस बात पर निर्भर करता है कि यह 32-बिट है या 64-बिट पर्ल मैं अनुमान लगाता हूं

— क्लॉडिउ

1000 साल ~ 3e10 सेकंड, तो आप अभी भी अपने आउटपुट के रूप में 1e21 के आसपास मंडराते रहेंगे। शायद अगर आपने 1e50 साल इंतजार किया, तो आप अन्य उत्तरों के खिलाफ प्रतिस्पर्धा शुरू कर सकते हैं?

— काइल कानोस

क्या आप इस "समय समय" का उच्चारण करते हैं? :-) (हाय

— टिमवी

क्या ब्रह्माण्ड की मृत्यु ताप पर समय दिन की बचत का हिसाब है? आप अस्तित्व के कुछ और सेकंड कमा सकते हैं।

— अल्फा

Answer 3

वोल्फ्राम ≅ 2.003529930 × 10 ¹⁹⁷²⁸

हाँ, यह एक भाषा है! यह लोकप्रिय वुल्फराम अल्फा साइट के बैक-एंड को ड्राइव करता है। यह एकमात्र भाषा है जहां मैंने पाया कि एकरमैन फ़ंक्शन अंतर्निहित है और संक्षिप्त रूप से 6 अक्षरों से कम है।

आठ अक्षरों में:

$ ack(4,2)

200352993...719156733

या ≅ 2.003529930 × 10 ¹⁹⁷²⁸

ack(4,3), ack(5,2)आदि बहुत बड़े हैं, लेकिन बहुत बड़े हैं। ack(4,2)संभवत: एक घंटे के तहत पूरी तरह से गणना की जा सकती है।

बड़े संख्याओं को प्रतीकात्मक रूप में प्रस्तुत किया जाता है, जैसे:

$ ack(4,3)

2↑²6 - 3 // using Knuth's up-arrow notation

नियम कहते हैं कि किसी भी आउटपुट स्वरूप की अनुमति है, इसलिए यह मान्य हो सकता है। यह अधिक से अधिक 10 ^{10 19,727} है, जो बार-बार भाज्य के अलावा अन्य प्रविष्टियों में से किसी यहां से बड़ा है।

हालाँकि,

$ ack(9,9)

2↑⁷12 - 3

दोहराया फैक्टरियल से बड़ा है। मुझे दस वर्णों में सबसे बड़ी संख्या मिल सकती है:

$ ack(99,99)

2↑⁹⁷102 - 3

यह बहुत बड़ा है, यूनिवर्स अपने अंकों के एक महत्वपूर्ण हिस्से का प्रतिनिधित्व करने के लिए पर्याप्त बड़ा नहीं है, भले ही आपने संख्या के बार-बार लॉग लिया हो।

Comments

बुरा नहीं है, लेकिन यह मेरे ack(4,2)+1समाधान के लिए कोई मुकाबला नहीं है ।

— user19057

ack (4,2) +2, I जीत

मुझे लगता है कि आप जीत गए।

— बेनामी पाइ

@ काइल, यिमिन इस पोस्ट में बहुत सारे भ्रामक बयान हैं और इसके तहत टिप्पणियां हैं। यह वह जगह है नहीं Wolfram भाषा, और नहीं क्या डब्ल्यू के बैकएंड के रूप में प्रयोग किया जाता है | एक। यह वुल्फराम के लिए बस "प्राकृतिक भाषा" इनपुट है। अल्फा। वुल्फ्राम भाषा ack(4,2)में अमान्य इनपुट है। डब्ल्यू | एक प्राकृतिक भाषा इनपुट को प्रोग्रामिंग भाषा के रूप में भी नहीं गिना जाना चाहिए। यह ट्यूरिंग पूर्ण नहीं है, और आप इसमें यूक्लिड के एल्गोरिथ्म जैसे बुनियादी कार्यक्रम भी नहीं लिख सकते हैं। इस कारण से मुझे नहीं लगता कि यह एक मान्य उत्तर है जो Google क्वेरी से अधिक होगा।

— शाबोलक्स

वोल्फ्राम लैंग्वेज मैथेमेटिका में इस्तेमाल की जाने वाली प्रोग्रामिंग लैंग्वेज है, जिसे यहां दस्तावेजित किया गया है । वोल्फ्राम | अल्फा प्राकृतिक भाषा को इनपुट के रूप में लेता है, वुल्फ्राम भाषा को नहीं।

— शाबोलक्स

Answer 4

पायथन 2 शेल, 3,010,301 अंक

9<<9999999

लंबाई की गणना: पायथन इन लंबी संख्याओं के लिए "एल" को जोड़ देगा, इसलिए यह परिणाम की तुलना में 1 वर्ण अधिक है।

>>> len(repr( 9<<9999999 ))
3010302

पहला और अंतिम 20 अंक:

40724177878623601356... ...96980669011241992192

Comments

इसे रफू करें! यह दिखाया, जबकि मैं एक ही जवाब लिख रहा था

— James_pic

यह वास्तव में बस है 9 * 2**9999999, इसलिए कोई यह तर्क दे सकता है कि यह घातांक का उपयोग करता है।

— डेनिस

रुको, ***built-in*** exponentiation functionsअनुमति नहीं है इसलिए यह नियमों के तहत पर्ची हो सकती है। +1

— user80551

लंबाई की गणना करने का गणितीय तरीका:floor(log10(9 * 2**9999999))+1

— जस्टिन

9 << (9 << 99) एक बहुत बड़ा है, अगर यह समाप्त हो जाता है।

— कीथ रान्डेल

Answer 5

सीजेएम, 2 × 10 ^268,435,457

A28{_*}*K*

यह गणना बी , इस प्रकार है:

• एक ₀ = 10

• a _n = a _{n - 1} ²

• b = २० × २ ₂₈

$ time cjam <(echo 'A28{_*}*K*') | wc -c
Real    2573.28
User    2638.07
Sys     9.46
268435458

पृष्ठभूमि

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

हालाँकि, एडिट्स के सुझाव को जावा 8 में अपग्रेड करने और 10 की शक्तियों का उपयोग करने के मेरे विचार ने सीजेएम को गोल्फस्क्रिप्ट की पहुंच से परे संख्याओं की गणना करने की अनुमति दी, जो रूबी के बिग्नम के कुछ कीड़े / सीमाओं के कारण लगता है।

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

A    " Push 10.                                                          ";
28{  " Do the following 28 times:                                        ";
  _* " Duplicate the integer on the stack and multiply it with its copy. ";
}*   "                                                                   ";
K*   " Multiply the result by 20.                                        ";

---

सीजाम, ≈ 8.1 × 10 ^1,826,751

KK,{)*_*}/

मेरी मशीन पर पाँच मिनट से कम समय लगता है, इसलिए अभी भी सुधार की गुंजाइश है।

यह एक ₂₀ गणना करता है , जो इस प्रकार है:

• एक ₀ = 20

• a _n = (n × a _{n - 1} ) ²

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

KK,   " Push 20 [ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ]. ";
{     " For each integer in the array:                                 ";
  )*  " Increment it and compute the its product with the accumulator. ";
  _*  " Multiply the result with itself.                               ";
}/

Comments

हाहा, क्या वो किर्बी? :)

— एडिट्स

क्या आप बता सकते हैं कि यह क्या कर रहा है?

— काइल कानोस

FYI करें, मैंने BigInteger प्रदर्शन की जांच के लिए कुछ परीक्षण चलाए - मैंने 100000 की गणना की! और स्ट्रिंग में परिवर्तित। परिणाम: java 6: 21 sec की गणना, 44 sec toString; जावा ring: १४ सेकंड की गणना, ४२ सेकंड की स्ट्रींग; जावा j: ५ सेकंड की गणना, १ सेकंड स्ट्रींग!

— aditsu

@aditsu: अपग्रेडिंग जावा ने रनटाइम को 5 मिनट से घटाकर 2 सेकंड कर दिया!

— डेनिस

Answer 6

पायथन 3, 9 * 2 ^ (7 * 2 ^ 33)> 10 ^ 18,100,795,813

9 * 2 ^ (2 ^ 35)> 10 ^ 10,343,311,894

संपादित करें: मेरा नया उत्तर है:

9<<(7<<33)

पुराना उत्तर, पोस्टर के लिए:

9<<(1<<35)

दस अक्षर बिल्कुल।

मैं हेक्स में संख्या को मुद्रित कर रहा हूं, और

आप कुछ भी प्रिंट करने के लिए आवश्यक किसी भी कोड को 10-वर्ण की सीमा से बाहर कर सकते हैं। उदाहरण के लिए, पायथन 2 में जो प्रिंट एक्स सिंटैक्स का उपयोग करता है, आप अपने प्रोग्राम के लिए अधिकतम 16 वर्णों का उपयोग कर सकते हैं।

इसलिए, मेरा वास्तविक कोड है:

print(hex(9<<(7<<33)))

सबूत है कि यह निर्दिष्ट समय में चलता है और निर्दिष्ट आकार का एक नंबर उत्पन्न करता है:

time python bignum.py > bignumoutput.py

real    10m6.606s
user    1m19.183s
sys    0m59.171s
wc -c bignumoutput.py 
15032385541 bignumoutput.py

मेरी संख्या> 10 ^ (15032385538 * लॉग (16))> 10 ^ 18100795813

प्रारंभिक के कारण उपरोक्त wc प्रिंटआउट की तुलना में 3 कम हेक्स अंक 0x9।

अजगर 3 आवश्यक है क्योंकि अजगर 2 में, 7<<33एक लंबा होगा, और <<इनपुट के रूप में लंबे समय तक नहीं लेता है।

मैं 9 << (1 << 36) का उपयोग नहीं कर सकता क्योंकि

Traceback (most recent call last):
  File "bignum.py", line 1, in <module>
    print(hex(9<<(1<<36)))
MemoryError

इस प्रकार, यह a<<(b<<cd)मेरे कंप्यूटर पर प्रिंट करने योग्य फ़ॉर्म की सबसे बड़ी संख्या है ।

सभी संभावना में, दुनिया की सबसे तेज़ मशीन में मेरे द्वारा की गई मेमोरी की तुलना में अधिक मेमोरी है, इसलिए मेरा वैकल्पिक उत्तर है:

9<<(9<<99)

9 * 2 ^ (9 * 2 ^ 99)> 10 ^ (1.7172038461 * 10 ^ 30)

हालाँकि, मेरा वर्तमान उत्तर सबसे बड़ा है जिसे किसी ने भी प्रस्तुत किया है, इसलिए यह संभवतः काफी अच्छा है। इसके अलावा, यह सब मानते हुए बिट-शिफ्टिंग स्वीकार्य है। इसका उपयोग करने वाले अन्य उत्तरों से यह प्रतीत होता है।

Comments

अब तक यह सबसे बड़ा जवाब है। यह एक 10,000,000,000 अंकों की संख्या है, सब के बाद।

— nnonneo

@nneonneo: मेरा मानना है कि मेरे समाधान बड़ा है :)

— ज़ैद

आपका वैकल्पिक जवाब की आवश्यकता है juuuuust स्मृति के कम से कम 1 MiYiB, और (इसलिए यह कम से कम 128 बिट अजगर जब तक काम नहीं करेगा) पता स्मृति के 100 बिट्स की आवश्यकता है। (स्रोत: मेरा समान उत्तर )

— wizzwizz4

Answer 7

किसी भी भाषा में कम पर्याप्त निरंतर नाम, 18 अंक लगभग।

99/sin(PI)

मैं इसे एक PHP उत्तर के रूप में पोस्ट करूंगा लेकिन दुख की बात M_PIयह है कि यह थोड़ा बहुत लंबा है! लेकिन इसके लिए PHP की पैदावार 8.0839634798317E + 17 है। मूल रूप से, यह पीआई: पी में पूर्ण परिशुद्धता की कमी का दुरुपयोग करता है

Comments

क्या आप तन (PI / 2) नहीं कर सकते?

— user80551

@ user80551 कर सकता है, लेकिन मैंने अभी देखा कि मैं अपने अंतिम परिणाम को 99 गुना बढ़ाने के लिए उस अंतिम शेष चरित्र का उपयोग कर सकता हूं।

— नीट द डार्क एबसोल

आम लिस्प में बहुत लंबा: (/ 99(sin pi))(14 अक्षर)। TI-83 में त्रुटि: 99/sin(π(8 वर्ण) शून्य से विभाजन का कारण बनता है। LibreOffice Calc में काम करता है : =99/SIN(PI((10 वर्ण, गिनती नहीं =) 808423047055000000 की गणना करता है। LibreOffice ऑटो पिछले दो ))को सम्मिलित करता है =99/SIN(PI())।

— कर्णघट

यह भाषा की शुद्धता पर निर्भर करता है। PHP में 14 दशमलव अंक एक सामान्य मूल्य है।

— kenorb

@kernigh इस मामले में कोई फर्क नहीं पड़ता, लेकिन 99/sin(πपांच बाइट्स या आठ होंगे? मुझे पता है कि TI-BASIC सिंगल बाइट्स के रूप में कमांड का एक गुच्छा संग्रहीत करता है; sin(उनमें से एक है?

— वचर्जिन

Answer 8

हास्केल

बिना किसी चाल के:

main = print -- Necessary to print anything
    $9999*9999 -- 999890001

किसी भी चीज़ की गणना के बिना तर्क:

main = print
    $floor$1/0 -- 179769313486231590772930519078902473361797697894230657273430081157732675805500963132708477322407536021120113879871393357658789768814416622492847430639474124377767893424865485276302219601246094119453082952085005768838150682342462881473913110540827237163350510684586298239947245938479716304835356329624224137216

नीट के उत्तर को अपनाना :

main = print
    $99/sin pi -- 8.083963479831708e17

Comments

तीसरी गोली कहती है, "आपके प्रोग्राम को गणना करनी चाहिए ..."

— user80551

floor(infinity)एक परिमित संख्या है? हेक हास्केल क्या है?

— nnonneo

1/0! = अनंत, यह अपरिभाषित है।

— रबरडुक

क्या आप इसके बारे में निश्चित हैं, @ ckuhn203? जीएचसी 7.6.3 और 7.8.2 दोनों में, मुझे मिलता है isInfinite $ 1 / 0 -- True। जहां तक ​​मैं बता सकता हूं, IEEE 754 1 / 0 अनंत के रूप में परिभाषित करता है ।

— टेलर फॉसक

ओह, आप का मतलब गणितीय है। मैं पूरी तरह से सहमत हूँ। लेकिन जहां तक ​​IEEE फ्लोटिंग पॉइंट (और विशेष रूप से हास्केल) के साथ प्रोग्रामिंग का संबंध है 1 / 0 == Infinity,।

— टेलर फासक

Answer 9

पॉवर्सशेल - 1.12947668480335E + 42

99PB*9E9PB

99 Pebibytes 9,000,000,000 Pebibytes गुणा करता है।

Comments

98901 वर्ग पेटाबाइट्स? क्या किसी प्रकार की सतह का घनत्व (भविष्य की उच्च क्षमता) हार्ड डिस्क को मापने के लिए है?

— user80551

ओह अच्छा। पता नहीं pebibytes अब तक संभव थे। मैंने हमेशा सोचा कि यह टेबीबाइट्स पर बंद हो गया।

— जॉय

@Joey अब अगर MS केवल जल्दी करेगा और yobibytes जोड़ देगा, तो उत्तर और भी बेहतर हो सकता है।

— रीनत

अगर यह मदद करता है, तो मैं इसे पाश में जोड़ सकता हूं; ;-)

— जॉय

1 + "1" * 309 आउटपुट 1.1111e308, हालांकि मुझे लगता है कि यह आत्मा को तोड़ता है, अगर मुद्रण वर्णों पर नियम का शब्द नहीं है। यह उत्पादन के लिए एक डबल करने के लिए डाली गई है।

— टॉमकिंडी

Answer 10

जे ( ((((((((9)!)!)!)!)!)!)!)!)

हाँ, यह बहुत है। 10^(10^(10^(10^(10^(10^(10^(10^6.269498812196425)))))))बहुत सटीक नहीं है।

!!!!!!!!9x

Comments

मुझे एक कंपाइलर मिला , लेकिन 20 मिनट के बाद, !!9xउसने स्क्रीन पर कुछ भी नहीं छापा। मैं ईमानदारी से संदेह है कि !!!!!!!!9xहोगा कभी गणना की।

— काइल कानोस

"अगर दुनिया के सबसे तेज़ कंप्यूटर पर चलने में एक घंटे से अधिक समय लगता है, तो यह अमान्य है।" यह निश्चित नहीं है कि यह मान्य होगा क्योंकि यह एक घंटे के भीतर नहीं चलता है

— क्लाउडी

इसमें 70 मिनट लगे, लेकिन !!9xआखिरकार स्क्रीन पर छप गया। मैं प्रभावित हूँ कि यह वास्तव में मूल्य की गणना करता है, लेकिन यह अभी भी पूरी तरह से विफल रहता है बुलेट 5.

— काइल कानोस

@Quincunx: संभवतः सच है, हालांकि एक वैध जवाब के लिए शर्त यह है कि कार्यक्रम को आउटपुट में सफल होना चाहिए; यह उत्तर उस कसौटी पर पूरी तरह से विफल है। अफसोस की बात है कि अपवित्रों ने सभी टिप्पणियों की उपेक्षा करते हुए इसे इंगित किया है और अभी भी इसे सीजेएम और गोल्फस्क्रिप्ट के जवाबों पर उकेरा है जो उचित समय में बहुत बड़ी और गणनात्मक हैं ।

— काइल कानोस

डाउनवोट किया गया क्योंकि यह जवाब नहीं छापता है।

— isaacg

Answer 11

के / कोना : 8.977649e261 1.774896e308

*/1.6+!170

• !170 0 से 169 तक संख्याओं का वेक्टर बनाता है
• 1.6+ वेक्टर के प्रत्येक तत्व में एक जोड़ता है और वास्तविक में परिवर्तित होता है (सीमा 1.6 से 170.6 है)
• */ सरणी के प्रत्येक तत्व को एक साथ गुणा करता है

अगर Kona ने क्वाड */9.+!999प्रिसिजन का समर्थन किया, तो मैं कर सकता था और लगभग 1e2584 प्राप्त कर सकता था । अफसोस की बात है, यह नहीं है और मैं डबल परिशुद्धता के लिए छाया हुआ है।

---

पुरानी विधि

*/9.*9+!99

• !99 0 से 98 तक संख्याओं का एक वेक्टर बनाता है
• 9+ वेक्टर के प्रत्येक तत्व में 9 जोड़ता है (अब 9 से 107 के बीच होता है)
• 9.* 9.0 से प्रत्येक तत्व को गुणा करता है (संक्षेप में वास्तविक में परिवर्तित होता है, इसलिए 81.0 963.0 के माध्यम से)
• */ वेक्टर के प्रत्येक तत्व को एक साथ गुणा करता है

Answer 12

HTML, 9999999999

9999999999

.. बिल्कुल सही किया।

Comments

एक प्रोग्रामिंग भाषा नहीं है, हालांकि।

— बिल्ली

PHP का उपयोग करें, यह बेहतर है!

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

@ इस मामले में, यह ठीक है, क्योंकि यह कोलमोगोरोव जटिलता चुनौतियों की याद दिलाता है।

— Addison Crump

9^9999प्रिंट करता है 9^9999। बस कहना :)

— जनवरी

दुख की बात PHP_INT_MAXहै 11

— ArtisticPhoenix

Answer 13

अजगर - भिन्न होता है, 13916486568675240 तक (अब तक)

पूरी तरह से गंभीर नहीं है लेकिन मुझे लगा कि यह थोड़े मजेदार होगा।

print id(len)*99

मेरी कोशिश की सभी चीजों में से, lenमुझे लगातार बड़ी आईडी मिल रही थी।

मेरे कंप्यूटर पर 13916486568675240 (17 अंक) और इस साइट पर 13842722750490216 (17 अंक भी) मिले । मुझे लगता है कि इसके लिए यह संभव है कि आप इसे कम से कम 0 दें, लेकिन यह अधिक हो सकता है।

Comments

महान विचार है लेकिन दुर्भाग्य से यह calculateकुछ भी नहीं है।

— user80551

मेरा मानना ​​है कि *99भाग एक गणना को आमंत्रित करता है।

— कमांडो

अरे हाँ, / मुझे अब बेवकूफ लगता है।

— user80551

आप कुछ कम उपयोग करते हैं - कहते हैं कि id(id)या id(0j), आप से गुणा कर सकते हैं999

— gnibbler

Docs.python.org/2/library/functions.html में छोटे नाम वाले लोगों में से , varsलगातार उच्चतम मूल्य (लेकिन 4 वर्ण) देता है sum। print(sorted([(id(x),x)for x in[id,len,max,min,str,int,ord,chr,sum,map,abs,all,any,bin,bool,eval,oct,vars,iter,list,set,repr,round,zip,type,pow,dict,dir,hex]])[::-1])जांच के लिए उपयोग करें।

— user80551

Answer 14

गोल्फस्क्रिप्ट, 1e + 33,554,432

10{.*}25*

10 ^ (2 ^ 25)घातांक का उपयोग किए बिना गणना , 96 सेकंड में चलती है:

$ time echo "10{.*}25*" | ruby golfscript.rb  > BIG10

real    1m36.733s
user    1m28.101s
sys     0m6.632s
$ wc -c BIG10
 33554434 BIG10
$ head -c 80 BIG10
10000000000000000000000000000000000000000000000000000000000000000000000000000000
$ tail -c 80 BIG10
0000000000000000000000000000000000000000000000000000000000000000000000000000000

यह गणना कर सकता है 9 ^ (2 ^ 9999), यदि केवल पर्याप्त समय दिया जाता है, लेकिन आंतरिक घातांक को एक करके बढ़ाकर इसे ~ तिगुना समय लगता है, इसलिए एक घंटे की सीमा बहुत जल्द पूरी हो जाएगी।

स्पष्टीकरण :

एक ही विचार के साथ पिछले संस्करण का उपयोग करना:

8{.*}25*

इसे तोड़कर:

8         # push 8 to the stack
{...}25*  # run the given block 25 times

प्रत्येक ब्लॉक की शुरुआत में स्टैक में एक संख्या, वर्तमान संख्या होती है। यह शुरू होता है 8। फिर:

.         # duplicate the top of the stack, stack is now | 8 | 8 |
*         # multiply top two numbers, stack is now       | 64 |

तो स्टैक, स्टेप बाय स्टेप, इस तरह दिखता है:

8
8 8
64
64 64
4096
4096 4096
16777216
16777216 16777216

... आदि गणित अंकन में लिखा है प्रगति है:

n=0, 8                     = 8^1  = 8^(2^0)
n=1, 8*8                   = 8^2  = 8^(2^1)
n=2, (8^2)*(8^2) = (8^2)^2 = 8^4  = 8^(2^2)
n=3,               (8^4)^2 = 8^8  = 8^(2^3)
n=4,               (8^8)^2 = 8^16 = 8^(2^4)

Comments

आपके आउटपुट में 2564 के सामने दो में से क्या है?

— काइल कानोस

@KyleKanos: यह मेरा आउटपुट नहीं है, यह आउटपुट है wc। मैं इसे स्पष्ट करने के लिए संपादन करूंगा

— क्लाउडी

आप wc -cआउटपुट को स्पष्ट करने के लिए उपयोग कर सकते हैं

— daniero

अच्छा! मेरे पास कुछ मिनट पहले एक ही विचार था, लेकिन यह सीजेएम के साथ बहुत धीमी गति से चलता है (जो आश्चर्यजनक है, क्योंकि यह सामान्य रूप से गोल्फस्क्रिप्ट से तेज है)।

— डेनिस

मामूली सुधार: 10{.*}25मेरी मशीन पर 90 सेकंड में 33,554,434 अंक और फिनिश देता है। मुझे पता नहीं क्यों, लेकिन 10{.*}26*कुछ भी नहीं छापता है।

— डेनिस

Answer 15

wxMaxima ~ 3x10 ^49,948 (या 10 ^{8,565,705,514} )

999*13511!

आउटपुट है

269146071053904674084357808139[49888 digits]000000000000000000000000000000

---

यकीन नहीं होता कि यह काफी फिट बैठता है (विशेष रूप से आउटपुट फॉर्मेट एक), लेकिन मैं इससे भी बड़ा हिट कर सकता हूं:

bfloat(99999999!)

आउटपुट है

9.9046265792229937372808210723818b8565705513

यह लगभग 10 ^{8,565,705,514 है} जो शीर्ष के अधिकांश उत्तरों की तुलना में काफी बड़ा है और लगभग 2 सेकंड में गणना की गई थी। bfloatसमारोह देता मनमाना परिशुद्धता ।

Answer 16

हास्केल, 4950

Aww आदमी, यह एक बहुत कुछ नहीं है! डॉलर के संकेत के बाद 10 अक्षर शुरू होते हैं।

main=putStr.show$sum[1..99]

Comments

सिर्फ क्यों नहीं print? इसके अलावा, 9/0.000001से अधिक है sum[1..99]।

— टेलर फॉसक

उस दर पर, हम परिणामों पर कम बाउंड होने के लिए ९९९९९९९९९९९ पर विचार कर सकते हैं।

— कीन

@TaylorFausak यह उत्तर स्पष्ट रूप से गंभीरता से नहीं लिया जाना है!

— फ्लोंक

Answer 17

गणितज्ञ, 2.174188391646043 * 10 ^ 20686623745

$MaxNumber

दस अक्षर बिल्कुल।

Comments

क्या यह तकनीकी रूप से किसी भी चीज की गणना कर रहा है, और क्या यह सभी अंकों का उत्पादन कर रहा है और न कि केवल वैज्ञानिक संकेतन?

@ येमिन: आउटपुट किसी भी प्रारूप में हो सकता है (ताकि आप 999, 5e + 100, आदि प्रिंट कर सकें)

— edc65

मूल्य संकलन-समय पर सेट नहीं किया गया है, लेकिन उस विशेष मशीन पर निर्भर करता है जिस पर कमांड चलाया जाता है। मुझे लगता है कि यह मायने रखता है।

— माइकल स्टर्न

Answer 18

पायथन शेल, 649539 999890001

हास्केल को धड़कता है, वास्तव में एक गंभीर जवाब नहीं है।

99999*9999

Comments

9999999999 बड़ा है, है ना?

— मैडक्स

@MadTux calculateउत्तर के लिए एक अस्पष्ट प्रतिबंध है ।

— user80551

यदि यह उत्तर सही है, तो मेरा 9**9**9**9भी सही है, क्योंकि यह अंकगणितीय ऑपरेटर है (बिल्ट-इन फंक नहीं)।

— केनोरब

@kenorb यह घातांक में बनाया गया है जिसकी अनुमति नहीं है।

— user80551

Answer 19

वोल्फ्राम अल्फा (एक वेबसाइट की भाषा के रूप में गिनती होती है)?

9! ! ! ! !

आउटपुट

10^(10^(10^(10^(10^(6.27...))))

टिप के लिए Cory के लिए धन्यवाद कि रिक्त स्थान और साथ ही साथ parens काम करते हैं।

Comments

मुझे पूरा यकीन है कि यह मेरी पोस्ट के रूप में थ्रेड में सबसे बड़ी संख्या है, लेकिन वोल्फ़्राम ने इसे अन्य नंबरों से तुलना करने पर चुटकी ली, यहां तक ​​कि ((99!)!)! > 4कभी नहीं लौटाया।

— गग्ग

यह नियम के विरुद्ध है जो कहता है कि आप इसे वेब से प्राप्त नहीं कर सकते।

— काइल कानोस

बहुत सारे डब्ल्यू | ए!

— बेनामी पाइ

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

— ggg

यह पूरी तरह से मान्य उत्तर है।

— माइक्रोबियन

Answer 20

बेफुंज -93 (1,853,020,188,851,841)

ख़ुशी की बात है कि किसी ने भी अभी तक Befunge नहीं किया है (यह मेरी जगह है), लेकिन मुझे लगता है कि संख्या बढ़ाने के लिए कोई भी चतुर चाल नहीं मिल सकती।

9:*:*:*:*.

तो यह 9 ^ 16 है।

:*

मूल रूप से स्वयं के साथ स्टैक के शीर्ष पर मूल्य को गुणा करता है। तो, स्टैक के शीर्ष पर मूल्य जाता है:

9
81
6561
43046721
1853020188851841

तथा

.

अंतिम मूल्य को आउटपुट करता है। मुझे यह देखने में दिलचस्पी होगी कि क्या किसी के पास कोई बेहतर विचार है।

Comments

मेरे पास एक बेहतर विचार है

— MildlyMilquetoast

Answer 21

मैं इसके बजाय ऊपर एक टिप्पणी के रूप में पोस्ट करूंगा, लेकिन जाहिर है मैं तब से नहीं कर सकता जब तक मैं एक नॉब नहीं हूं।

अजगर:

9<<(2<<29)

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

9<<(7<<27)

इनके साथ एकमात्र समस्या यह है कि वे नियम 5 को संतुष्ट नहीं कर सकते हैं।

Answer 22

मतलाब (1.7977e + 308)

Matlab नामक चर में सबसे बड़ी (डबल-परिशुद्धता) फ़्लोटिंग-पॉइंट संख्या का मान संग्रहीत करता है realmax। कमांड विंडो में (या कमांड लाइन पर) इसे लागू करने से इसकी वैल्यू प्रिंट हो जाती है:

>> realmax

ans =

  1.7977e+308

Comments

चूंकि ओपी ने एक परिकलित मान वापस करने के लिए कहा , इसलिए आपको कहना चाहिए realmax+1। मैंने इसे मज़े के लिए आज़माया और आश्चर्यचकित कर दिया कि यह आपके पास की तुलना में ठीक उसी नंबर पर है (तब मुझे हंसी आई जब मुझे एहसास हुआ ... eps(realmax)=1.99584030953472e+292)।

— होकी

Answer 23

अजगर, सीए। 1.26e1388

9<<(9<<9L)

देता है:

126026689735396303510997749074166929355794746000200933374690887068497279540873057344588851620847941756785436041299246554387020554314993586209922882758661017328592694996553929727854519472712351667110666886882465827559219102188617052626543482184096111723688960246772278895906137468458526847698371976335253039032584064081316325315024075215490091797774136739726784527496550151562519394683964055278594282441271759517280448036277054137000457520739972045586784011500204742714066662771580606558510783929300569401828194357569630085253502717648498118383356859371345327180116960300442655802073660515692068448059163472438726337412639721611668963365329274524683795898803515844109273846119396045513151325096835254352967440214290024900894106148249792936857620252669314267990625341054382109413982209048217613474462366099211988610838771890047771108303025697073942786800963584597671865634957073868371020540520001351340594968828107972114104065730887195267530118107925564666923847891177478488560095588773415349153603883278280369727904581288187557648454461776700257309873313090202541988023337650601111667962042284633452143391122583377206859791047448706336804001357517229485133041918063698840034398827807588137953763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L3763403631303885997729562636716061913967514574759718572657335136386433456038688663246414030999145140712475929114601257259572549175515657577056590262761777844800736563321827756835035190363747258466304L

Answer 24

कम से कम अजगर 3.5.0 (64-बिट), 10 ^ 242944768872896860 से अधिक

print("{:x}".format( 9<<(7<<60) ))

एक आदर्श दुनिया में, यह होगा 9<<(1<<63)-1, लेकिन उसके लिए पर्याप्त बाइट्स नहीं हैं। यह संख्या इतनी बड़ी है कि इसे धारण करने के लिए लगभग 1 EiB मेमोरी की आवश्यकता होती है, जो मेरे कंप्यूटर पर मेरे द्वारा की गई तुलना में थोड़ा अधिक है। सौभाग्य से, आपको इसे धारण करने के लिए स्वैप के रूप में केवल विश्व के संग्रहण स्थान का लगभग 0.2% उपयोग करने की आवश्यकता है। बाइनरी में मूल्य 10018070450532247928832 शून्य है।

यदि पायथन 128-बिट मशीनों के लिए निकलता है, तो अधिकतम होगा 9<<(9<<99), जिसके लिए मेमोरी के 1 MiYiB से कम की आवश्यकता होती है। यह अच्छा है, क्योंकि आपके पास पाइथन इंटरप्रेटर और ऑपरेटिंग सिस्टम को स्टोर करने के लिए पर्याप्त पता योग्य जगह बची होगी।

Comments

"दुनिया के भंडारण स्थान का केवल 0.2%"

— बेंजामिन अर्कहार्ट

@BenjaminUrquhart यदि आपको लगता है कि यह अच्छा है, तो अपवोट क्यों नहीं?

— wizzwizz4

आपका डबल अपवोट है;)

— बेंजामिन अर्कहार्ट

Answer 25

Cubix , 9.670457478596419e + 147 (गैर प्रतिस्पर्धा)

****"///**

गैर-प्रतिस्पर्धा क्योंकि क्यूबिक्स इस चुनौती से नया है। आप इसे यहाँ ऑनलाइन परीक्षण कर सकते हैं , लेकिन ध्यान दें कि यह वास्तव में संख्या को प्रिंट नहीं करता है; *स्टैक पर मान देखने के लिए अंतिम दो एस चलने के बाद आपको कार्यक्रम को रोकना होगा ।

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

क्यूबिक्स एक 2-आयामी एसोलैंग है जहां कोड एक क्यूब के चारों ओर लपेटा जाता है। यह कोड निम्नलिखित क्यूब नेट के समतुल्य है, जहां .कोई विकल्प नहीं है:

    * *
    * *
" / / / * * . .
. . . . . . . .
    . .
    . .

फिर कोड चलाया जाता है, अनुदेश सूचक (आईपी) बाएं चेहरे के शीर्ष-बाएं कोने से शुरू होता है, दाएं का सामना करना पड़ता है। "स्ट्रिंग मोड को चालू करता है, जहां अगले चार्ट तक सभी वर्णों का सामना करना पड़ता है, "उनके चार-कोड को स्टैक पर धक्का देते हैं। आईपी ​​तीन कोड /(47), दो *एस (42), और दो को धकेलते हुए कोड के चारों ओर घूमता है. फिर से स्ट्रिंग मोड से बाहर निकलने से पहले, एस (46) को ।

यहां यह दिलचस्प है। पहला दर्पण /आईपी ​​को दर्शाता है इसलिए यह सामना कर रहा है; यह फिर घन के चारों ओर घूमता है, इन वर्णों को मारता है:

           
    * *
  /     *      
  .     .      
    . .

तीन *एस ढेर पर शीर्ष दो आइटम गुणा करते हैं। अब, अधिकांश स्टैक-आधारित भाषाओं के विपरीत जहां अंकगणित ऑपरेटर अपने तर्क देते हैं, क्यूबिक्स पिछले मानों को स्टैक पर छोड़ देता है। तो इसका मतलब है कि यह गणना करता है 46*46 = 2116, 46*2116 = 97336, 2116*97336 = 205962976।

जब आईपी /फिर से पहुंचता है , तो यह सही हो जाता है। इसके बाद अगला दर्पण टकराता है और इस मार्ग का अनुसरण करता है:

    *  
    *  
    /         .
    .         .
    .  
    .  

दो तारांकन शीर्ष दो आइटमों को एक बार फिर से गुणा करते हैं। फिर दर्पण आईपी को फिर से निर्देशित करता है, और तीसरा दर्पण प्रक्रिया को एक बार फिर से दोहराता है:

      *
      *
      /     .  
      .     .  
      .
      .

अंत में, आईपी दर्पण अनुभाग को पूर्व की ओर अग्रसर करता है। दो अंतिम रूप से तारांकन दो बार और गुणा करते हैं, जिससे ढेर पर 9.670457478596419e + 147 का परिणाम होता है। इस के साथ मुद्रित किया जा सकता है O, लेकिन ऐसा करने का कोई आसान तरीका नहीं है क्योंकि व्यावहारिक रूप से क्यूब पर प्रत्येक स्थान पहले से ही उपयोग किया जाता है।

Answer 26

स्काला, 2 ⁶³ -1

गरीब, गरीब स्काला। पाने के लिए कम से कम 8 अक्षर लेता हैBigIntमान , जो वास्तव में इसे बड़ा बनाने के लिए पर्याप्त जगह नहीं छोड़ता है।

लेकिन (गिने हुए) कोड के केवल 7 अक्षरों के साथ, हम सबसे बड़ा पॉजिटिव प्रिंट कर सकते हैं Long:

print(-1L>>>1)

Answer 27

ब्रेनफ ** k 256 - 2147483647

>+[<+>+]<.

_{यदि आप इस तथ्य को नजरअंदाज करते हैं कि अधिकांश कंपाइलर और दुभाषिए आउटपुट डेटा को ascii समतुल्य मानते हैं (दुबला-पतला होना, यह वही है?)} , तो यह दुभाषिया / संकलक के डेटाटाइप का अधिकतम मान लौटाएगा।

कुछ प्रणालियों पर यह सिर्फ 256 है, हालांकि कुछ पर (उदाहरण के लिए मेरा), यह एक 32 बिट पूर्णांक का अधिकतम मूल्य है, अर्थात 2 147 483 647।

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

-.

कई कम वर्णों में एक ही बात छापेंगे

Comments

वह दूसरा उत्तर छपेगा -1 व्याख्याकारों पर

— छपेगा

Answer 28

पर्ल, गैर-प्रतिस्पर्धात्मक

मैं पर्ल के एक छोटे से कोने को उजागर करने के लिए इसका उपयोग कर रहा हूं।

पर्ल वास्तव में इस पर प्रतिस्पर्धा नहीं कर सकता है क्योंकि इसमें बिलिन बग्नम्स नहीं हैं (निश्चित रूप से आप एक बिग्नम लाइब्रेरी लोड कर सकते हैं)।

लेकिन हर कोई जानता है कि पूरी तरह से सच नहीं है। एक मुख्य कार्य वास्तव में बड़ी संख्या को संभाल सकता है।

packप्रारूप wवास्तव में आधार के बीच किसी भी आकार प्राकृतिक संख्या में बदल सकते हैं 10और आधार 128। बेस 128 पूर्णांक को हालांकि स्ट्रिंग बाइट्स के रूप में दर्शाया गया है। बिटस्ट्रिंग xxxxxxxyyyyyyyzzzzzzzबाइट्स बन जाते हैं: 1xxxxxxx 1yyyyyyy 0zzzzzzz(हर बाइट 1 से शुरू होती है सिवाय आखिरी के)। और आप इस तरह के स्ट्रिंग को अनपैक के साथ बेस 10 में बदल सकते हैं। तो आप कोड लिख सकते हैं जैसे:

unpack w,~A x 4**4 .A

जो देता है:

17440148077784539048602210552864286760481312243331966651657423831944908597692986131110771184688683631223604950868378426010091037391551287028966465246275171764867964902846884403624214574779667949236313638077978794791039372380746518407204456880869394123452212674801443116750853569815557532270825838757922217314748231826241930826238846175896997055564919425918463307658663171965135057749089077388054942032051553760309927468850847772989423963904144861205988704398838295854027686335454023567793114837657233481456867922127891951274737700618284015425

आप 4**4बड़े मूल्यों से बदल सकते हैं जब तक आपको लगता है कि यह बहुत लंबा है या बहुत अधिक स्मृति का उपयोग करता है।

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

Answer 29

TI-36 (84 नहीं, 36), 10 बाइट्स, लगभग। 9.999985426E99

पुराने कैलकुलेटरों को एक हद तक क्रमादेशित किया जा सकता है;)

69!58.4376

यह अधिकतम सीमा के करीब है जिसे TI कैलकुलेटर प्रदर्शित कर सकता है:-1E100<x<1E100

Answer 30

पर्ल 6 , 456,574 अंक

[*] 1..ↈ

कोई TIO नहीं क्योंकि इसे चलाने में 2 मिनट लगते हैं।