एक कंपाइलर बम बनाएँ

Question

परिचय

आप शायद जिप बम , एक्सएमएल बम आदि से परिचित हैं । सीधे शब्दों में कहें, तो वे (अपेक्षाकृत) छोटी फाइलें होती हैं, जो भोले-भाले सॉफ़्टवेयर द्वारा व्याख्या किए जाने पर बहुत अधिक उत्पादन करती हैं। यहां चुनौती एक कंपाइलर को उसी तरह से गाली देना है।

चुनौती

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

नियम

ठीक है, इसलिए कुछ महत्वपूर्ण स्पष्टीकरण, परिभाषाएं और प्रतिबंध हैं;

• संकलन का आउटपुट एक ELF फ़ाइल, एक Windows पोर्टेबल निष्पादन योग्य (.exe) होना चाहिए , या JVM या .Net के CLR के लिए वर्चुअल बाईटेकोड (यदि पूछा जाए तो अन्य प्रकार के वर्चुअल बायोटेक भी ठीक होने की संभावना है)। अपडेट: पायथन का .pyc / .pyo आउटपुट भी मायने रखता है ।
• यदि आपकी भाषा-पसंद को सीधे उन प्रारूपों में से एक में संकलित नहीं किया जा सकता है, तो संकलन के बाद होने वाले ट्रांसप्लीकेशन की भी अनुमति है ( अपडेट: आप कई बार ट्रांसपाइल कर सकते हैं, बस इतनी देर तक जब आप एक ही भाषा का एक से अधिक बार उपयोग नहीं करते हैं )।
• आपके स्रोत कोड में कई फाइलें और यहां तक ​​कि संसाधन फाइलें शामिल हो सकती हैं, लेकिन इन सभी फाइलों का सार आकार 512 बाइट्स से अधिक नहीं होना चाहिए।
• आप अपनी स्रोत फ़ाइल (ओं) और अपनी भाषा के मानक पुस्तकालय की तुलना में किसी अन्य इनपुट का उपयोग नहीं कर सकते। स्टैटिक लिंकिंग स्टैण्डर्ड लाइब्रेरियाँ ठीक है जब यह समर्थित है। विशेष रूप से, कोई तृतीय पक्ष लाइब्रेरी या OS लाइब्रेरी नहीं है।
• आदेश या आदेशों की श्रृंखला का उपयोग करके अपने संकलन को लागू करना संभव होगा। यदि आपको संकलन करते समय विशिष्ट झंडे की आवश्यकता होती है, तो ये आपकी बाइट सीमा की ओर गिनते हैं (जैसे कि यदि आपका संकलन लाइन है gcc bomb.c -o bomb -O3 -lm, तो -O3 -lmभाग (7 बाइट्स) की गणना की जाएगी (ध्यान दें कि प्रारंभिक अग्रणी स्थान की गिनती नहीं की गई है)।
• प्रीप्रोसेसर को केवल तभी अनुमति दी जाती है जब वे आपकी भाषा के लिए एक मानक संकलन विकल्प हों।
• पर्यावरण आप पर निर्भर है, लेकिन इस सत्य को बनाने के हितों में, कृपया हाल के (यानी उपलब्ध) संकलक संस्करणों और ऑपरेटिंग सिस्टम (और स्पष्ट रूप से जो आप उपयोग कर रहे हैं) निर्दिष्ट करें।
• यह त्रुटियों के बिना संकलित होना चाहिए (चेतावनियां ठीक हैं), और संकलक को क्रैश करना किसी भी चीज के लिए गणना नहीं करता है।
• क्या अपने कार्यक्रम वास्तव में करता है अप्रासंगिक है, हालांकि यह कुछ भी दुर्भावनापूर्ण नहीं हो सकता। यह भी शुरू करने में सक्षम होने की जरूरत नहीं है।

उदाहरण 1

सी कार्यक्रम

main(){return 1;}

Apple LLVM version 7.0.2 (clang-700.1.81)OS X 10.11 (64-बिट) पर संकलित :

clang bomb.c -o bomb -pg

9228 बाइट्स की एक फ़ाइल का उत्पादन करता है। कुल स्रोत का आकार 17 + 3 (के लिए -pg) = 20 बाइट्स है, जो आसानी से आकार सीमा के भीतर है।

उदाहरण 2

ब्रेनफक कार्यक्रम:

++++++[->++++++++++++<]>.----[--<+++>]<-.+++++++..+++.[--->+<]>-----.--
-[-<+++>]<.---[--->++++<]>-.+++.------.--------.-[---<+>]<.[--->+<]>-.

के साथ c में awib के साथ संचरित :

./awib < bomb.bf > bomb.c

फिर Apple LLVM version 7.0.2 (clang-700.1.81)OS X 10.11 (64-बिट) पर संकलित :

clang bomb.c

8464 बाइट्स की एक फ़ाइल का उत्पादन करता है। यहां कुल इनपुट 143 बाइट्स है (क्योंकि @lang_cओबेर के लिए डिफ़ॉल्ट यह स्रोत फ़ाइल में जोड़ने की आवश्यकता नहीं है, और कमांड पर कोई विशेष झंडे नहीं हैं)।

इस बात पर भी ध्यान दें कि इस मामले में, अस्थायी बॉम्बे फ़ाइल फ़ाइल 802 बाइट्स है, लेकिन यह न तो स्रोत आकार और न ही आउटपुट आकार की ओर गिना जाता है।

अंतिम नोट

यदि 4GB से अधिक का आउटपुट प्राप्त किया जाता है (शायद अगर किसी को ट्यूरिंग पूर्ण प्रीप्रोसेसर मिल जाए), तो प्रतियोगिता सबसे छोटे स्रोत के लिए होगी जो कम से कम उस आकार की फ़ाइल का उत्पादन करता है (यह सबमिशन का परीक्षण करने के लिए व्यावहारिक नहीं है जो बहुत बड़ा हो जाता है) ।

Comments

यदि ट्रांसपाइलर का उपयोग किया जाता है, तो आउटपुट स्रोत कोड को 512 बाइट्स के साथ-साथ इनपुट स्रोत कोड के तहत होना चाहिए?

— ट्राइकोप्लाक्स 23

क्या दोहराए जाने की अनुमति है?

— orlp

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

— डेव

@trichoplax मैं उस के बारे में पता नहीं था, लेकिन कुछ पढ़ने से यह हाँ की तरह लग रहा है; पायथन बाइटकोड को संकलन बिल्कुल मायने रखता है। तो अजगर के लिए, आउटपुट आकार आपके सभी pyc / pyo फ़ाइलों का कुल आकार होगा। मैं इन टिप्पणियों-आधारित अपडेट के साथ जल्द ही प्रश्न को अपडेट करूंगा।

— डेव

@MartinRosenau - WGroleau ने पहले ही एक समान प्रश्न पूछा था; यह कोडिंग चुनौतियों में मानक है कि आप कुछ भी उपयोग कर सकते हैं जो चुनौती शुरू होने पर पहले से मौजूद है ।

— डेव

Answer 1

सी, (14 + 15) = 29 बाइट स्रोत, 17,179,875,837 (16 जीबी) बाइट निष्पादन योग्य

6 बाइट्स के लिए @viraptor को धन्यवाद।

2 बाइट्स और निष्पादन योग्य आकार x4 के लिए @hvd का धन्यवाद।

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

क्योंकि यह सरणी 2GB से बड़ी है, इसलिए हमें -mcmodel=mediumGCC को ध्वज प्रदान करना होगा । नियमों के अनुसार, अतिरिक्त 15 बाइट्स स्कोर में शामिल हैं।

main[-1u]={1};

जब भी कुछ अच्छा लगे इस कोड की उम्मीद न करें।

संकलन:

gcc -mcmodel=medium cbomb.c -o cbomb

---

मुझे @ hvd के सुझाव का परीक्षण करने में काफी समय लग गया - और इसे संभालने के लिए पर्याप्त रस वाली मशीन की खोज की। आखिरकार मुझे 10GB रैम, 12GB स्वैप, और / tmp के साथ एक बड़े स्थानीय विभाजन के लिए एक पुराना गैर-उत्पादन RedHat 5.6 VM मिला। जीसीसी संस्करण 4.1.2 है। कुल संकलन समय लगभग 27 मिनट।

सीपीयू और रैम लोड के कारण, मैं इस संकलन को किसी भी दूरस्थ उत्पादन-संबंधित मशीन पर करने की सलाह देता हूं ।

Comments

@ सपर तत्वों के लापता मानों को 0 से शुरू किया जाएगा

— डिजिटल ट्रॉमा

मैं यहाँ अपने समाधान के खिलाफ खेल रहा हूँ, लेकिन ... आपको ज़रूरत नहीं है a। आप बस इस्तेमाल कर सकते हैंmain[1<<30]={1};

— viraptor

अरे मेरा। यह बुराई है। उस कोड को संकलित करने की कोशिश में कई मिनट तक जम कर एक्स। मैं दूसरे कंप्यूटर की तलाश शुरू कर रहा था और संभवतः gcc प्रक्रिया को मार सकता था और इससे पहले कि वह जीवन में वापस आ जाए। Btw। यदि आप इससे बड़ा मूल्य चाहते हैं 1<<30तो 7<<28एक विकल्प हो सकता है।

— कास्परड

> 4GB? यह जल्दी से आगे बढ़ा

— वेन वर्नर

मामले में कोई और सोच रहा है कि यह संकलन क्यों है: stackoverflow.com/questions/34764796/…

— TC

Answer 2

C #, संकलन करने के लिए लगभग 1 मिनट, 28MB आउटपुट बाइनरी:

class X<A,B,C,D,E>{class Y:X<Y,Y,Y,Y,Y>{Y.Y.Y.Y.Y.Y.Y.Y.Y y;}}

अधिक वाई के जोड़ने से आकार में तेजी से वृद्धि होगी।

@Odomantois के अनुरोध के अनुसार चरण द्वारा एक स्पष्टीकरण:

यह उत्तर वंशानुक्रम का दुरुपयोग कर रहा है और पुनरावर्तन बनाने के लिए पैरामीटर टाइप करता है। यह समझने के लिए कि क्या हो रहा है, पहले समस्या को सरल करना आसान है। विचार करें class X<A> { class Y : X<Y> { Y y; } }, जो सामान्य वर्ग उत्पन्न करता है X<A>, जिसके पास एक आंतरिक वर्ग है Y। X<A>.Yविरासत X<Y>, इसलिए X<A>.Yभी एक आंतरिक वर्ग है Y, जो तब है X<A>.Y.Y। इसके बाद एक आंतरिक वर्ग भी होता है Y, और उस आंतरिक वर्ग Yमें एक आंतरिक वर्ग Yआदि होता है। इसका मतलब है कि आप गुंजाइश रिज़ॉल्यूशन ( .) विज्ञापन इनफ़िनिटम का उपयोग कर सकते हैं , और हर बार जब आप इसका उपयोग करते हैं, तो कंपाइलर को विरासत का एक और स्तर काटना पड़ता है और पैरामीटर पैरामीटर टाइप करना पड़ता है ।

अतिरिक्त प्रकार के मापदंडों को जोड़कर, कंपाइलर को प्रत्येक चरण में जो काम करना होता है वह और बढ़ जाता है।

निम्नलिखित मामलों पर विचार करें:
में class X<A> { class Y : X<Y> { Y y;} }प्रकार परम Aका एक प्रकार है X<A>.Y।
में class X<A> { class Y : X<Y> { Y.Y y;} }प्रकार परम Aका एक प्रकार है X<X<A>.Y>.Y।
में class X<A> { class Y : X<Y> { Y.Y.Y y;} }प्रकार परम Aका एक प्रकार है X<X<X<A>.Y>.Y>.Y।
में class X<A,B> { class Y : X<Y,Y> { Y y;} }प्रकार परम Aहै X<A,B>.Yऔर Bहै X<A,B>.Y।
में class X<A> { class Y : X<Y> { Y.Y y;} }प्रकार परम Aहै X<X<A,B>.Y, X<A,B>.Y>.Yऔर Bहै X<X<A,B>.Y, X<A,B>.Y>.Y।
में class X<A> { class Y : X<Y> { Y.Y.Y y;} }प्रकार परम Aहै X<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Yऔर Bहै X<X<X<A,B>.Y, X<A,B>.Y>.Y, X<X<A,B>.Y, X<A,B>.Y>.Y>.Y।

इस पैटर्न के बाद, कोई केवल ¹ काम की कल्पना कर सकता है कि कंपाइलर को यह तय करने के लिए क्या Aकरना होगा कि परिभाषा में क्या Eहैं ।Y.Y.Y.Y.Y.Y.Y.Y.Yclass X<A,B,C,D,E>{class Y:X<Y,Y,Y,Y,Y>{Y.Y.Y.Y.Y.Y.Y.Y.Y y;}}

¹ आप इसका पता लगा सकते हैं, लेकिन आपको बहुत धैर्य की आवश्यकता होगी, और अंतर्मुखता आपकी मदद नहीं करेगी।

Comments

यह उस तरह के पागलपन की तरह है जिसकी मुझे उम्मीद थी! ऐसा लगता है कि मैं मोनो को पुन: स्थापित करने के लिए बंद हूं ...

— डेव

क्या आप इस तरह के कुख्यात प्रभाव की व्याख्या प्रदान कर सकते हैं?

— ओडोमेंटोइस

+1 एक बड़े सरणी को आरंभीकृत करने से अधिक करने के लिए।

— स्टिग हेमर

यहाँ Try Roslyn और सिर्फ 3 Ys का उपयोग करके एक उदाहरण दिया गया है ।

— कोबी

मैंने इस सवाल को देखा और तुरंत आपके बारे में सोचा। अच्छा!

— एरिक लिपर्ट

Answer 3

पायथन 3, 13 बाइट स्रोत, 9,057,900,463 बाइट (8.5GiB) .pyc-file

(1<<19**8,)*2

संपादित करें : नियमों को महसूस करने के बाद ऊपर दिए गए संस्करण में कोड को बदल दिया गया है, क्योंकि 4GiB से परे आउटपुट का आकार कोई मायने नहीं रखता है, और इस कोड के लिए कोड कभी इतना छोटा होता है; पिछला कोड - और अधिक महत्वपूर्ण रूप से स्पष्टीकरण - नीचे पाया जा सकता है।

---

पायथन 3, 16 बाइट स्रोत,> 32TB .pyc-file (यदि आपके पास पर्याप्त मेमोरी, डिस्क स्थान और धैर्य है)

(1<<19**8,)*4**7

व्याख्या: पायथन 3 निरंतर तह करता है, और आप घातांक के साथ बड़ी संख्या में तेजी से प्राप्त करते हैं। .Pyc फ़ाइलों द्वारा उपयोग किया जाने वाला प्रारूप 4 बाइट्स का उपयोग करके पूर्णांक प्रतिनिधित्व की लंबाई को संग्रहीत करता है, हालांकि, और वास्तव में सीमा अधिक पसंद की जाती है 2**31, इसलिए एक बड़ी संख्या उत्पन्न करने के लिए सिर्फ घातांक का उपयोग करते हुए, सीमा 2GB उत्पन्न होती है। 8 बाइट स्रोत से pyc फ़ाइल। ( 19**8थोड़ा शर्मीला है 8*2**31, इसलिए 1<<19**8केवल 2GB के तहत एक द्विआधारी प्रतिनिधित्व है; आठ से गुणा इसलिए है क्योंकि हम बाइट्स चाहते हैं, बिट्स नहीं)

हालांकि, ट्यूपल भी अपरिवर्तनीय हैं और एक ट्यूपल को गुणा करना भी लगातार मुड़ा हुआ है, इसलिए हम उस 2GB को जितनी बार चाहें उतनी बार डुप्लिकेट कर सकते हैं, कम से कम 2**31समय तक, शायद। 4**732TB को पाने के लिए चुना गया था सिर्फ इसलिए कि यह पहली बार प्रतिपादक मुझे लगता है कि पिछले 16TB जवाब हरा मिल सकता था।

दुर्भाग्य से, स्मृति मेरे पास अपने कंप्यूटर पर है, मैं केवल 2 के गुणक तक इसका परीक्षण कर सकता हूं, अर्थात। (1<<19**8,)*2, जिसने 8.5GB फ़ाइल उत्पन्न की, जो मुझे आशा है कि उत्तर यथार्थवादी है (यानी फ़ाइल का आकार 2 ** 32 = 4GB तक सीमित नहीं है)।

इसके अलावा, मुझे नहीं पता कि परीक्षण के दौरान मुझे जो फ़ाइल आकार मिला, वह 4GB-ish की उम्मीद के बजाय 8.5GB था, और फ़ाइल काफी बड़ी है कि मुझे इस समय इसके आसपास झाँकने का मन नहीं है।

Comments

+1, लेकिन क्यों नहीं (1<<19**8,)*2? 4GB पर्याप्त है।

— अकाँका

@ChristianIrwan: हाँ, मैं उस नियम को भूल गया था, केवल कुछ मिनट पहले ही यह महसूस किया था और मुझे यह पता नहीं लगा है कि मुझे अभी तक किस तरह का संपादन करना चाहिए। :-)

— अलेक्सई तोरोमो

अच्छा लगा। चूंकि यह केवल 13 बाइट्स है, इसलिए हमारे पास पहले पोस्ट किए गए उत्तर के लिए एक चुनौती है! मैं केवल 1<<18अपनी मशीन (1.5GB) पर पुष्टि करने में सक्षम था, लेकिन मैं इसे बाद में लिनक्स पर परीक्षण करूंगा, जहां मुझे उम्मीद है कि यह पूर्ण 8GB (32TB संस्करण की कोशिश नहीं करने वाला!) के साथ काम करेगा

— डेव

@ मूल्य: सटीक आकार संस्करण पर निर्भर हो सकता है (1.5GB अजीब लगता है कि कोई फर्क नहीं पड़ता कि क्या, हालांकि); मैं पायथन 3.3.5 का उपयोग कर रहा था, और python -m py_compile asd.py.pyc-file को उत्पन्न करने के लिए उपयोग किया जाता था।

— अलेक्सी तोहारामो

IIRC, अजगर अपने पूर्णांक प्रतिनिधित्व में 32-बिट शब्द प्रति 30 बिट्स का उपयोग करता है

— बहिष्कृत और बंद

Answer 4

यदि 4GB से अधिक का आउटपुट प्राप्त किया जाता है (शायद अगर किसी को ट्यूरिंग पूर्ण प्रीप्रोसेसर मिल जाए), तो प्रतियोगिता सबसे छोटे स्रोत के लिए होगी जो कम से कम उस आकार की फ़ाइल का उत्पादन करता है (यह सबमिशन का परीक्षण करने के लिए व्यावहारिक नहीं है जो बहुत बड़ा हो जाता है) ।

"टेम्पलेट हास्केल" हास्केल का उपयोग करते हुए संकलन-समय पर हास्केल कोड उत्पन्न करने की अनुमति देता है, और इसलिए यह एक पूर्ण ट्यूरिंग प्रोसेसर है।

यहाँ मेरा प्रयास है, एक मनमाना संख्यात्मक अभिव्यक्ति द्वारा पैरामीटरित FOO:

import Language.Haskell.TH;main=print $(ListE .replicate FOO<$>[|0|])

जादू "ब्याह" के अंदर का कोड है $(...)। इसे एक हास्केल एएसटी उत्पन्न करने के लिए संकलन समय पर निष्पादित किया जाएगा, जिसे स्प्लिट के स्थान पर प्रोग्राम के एएसटी पर ग्राफ्ट किया गया है।

इस मामले में, हम शाब्दिक का प्रतिनिधित्व करने के लिए एक सरल एएसटी बनाने के 0लिए, हम इस को दोहराने FOOएक सूची बनाने के लिए कई बार, तो हम का उपयोग ListEसे Language.Haskell.THमॉड्यूल एक बड़ा एएसटी में ASTs की इस सूची में चालू करने के लिए, शाब्दिक का प्रतिनिधित्व [0, 0, 0, 0, 0, ...]।

जिसके परिणामस्वरूप कार्यक्रम के बराबर है main = print [0, 0, 0, ...]के साथ FOOकी पुनरावृत्ति 0।

ELF के संकलन के लिए:

$ ghc -XTemplateHaskell big.hs
[1 of 1] Compiling Main             ( big.hs, big.o )
Linking big ...
$ file big
big: ELF 32-bit LSB executable, Intel 80386, version 1 (SYSV), dynamically linked, interpreter /nix/store/mibabdfiaznqaxqiy4bqhj3m9gaj45km-glibc-2.21/lib/ld-linux.so.2, for GNU/Linux 2.6.32, not stripped

इसका वजन 83 बाइट्स (हास्केल कोड के लिए 66 और -XTemplateHaskellतर्क के लिए 17 ) में है, साथ ही लंबाई भी FOO।

हम संकलक तर्क से बच सकते हैं और बस संकलन कर सकते हैं ghc, लेकिन हमें {-# LANGUAGE TemplateHaskell#-}शुरुआत में रखना होगा , जो 97 बाइट तक कोड को टक्कर देता है।

यहाँ कुछ उदाहरण अभिव्यक्तियाँ हैं FOO, और परिणामी बाइनरी का आकार:

FOO         FOO size    Total size    Binary size
-------------------------------------------------
(2^10)      6B          89B           1.1MB
(2^15)      6B          89B           3.6MB
(2^17)      6B          89B           12MB
(2^18)      6B          89B           23MB
(2^19)      6B          89B           44MB

मैं बाहर भाग गया RAM के साथ संकलन (2^20)।

हम repeatइसके बजाय का उपयोग करके एक अनंत सूची भी बना सकते हैं replicate FOO, लेकिन यह कंपाइलर को रोकने से रोकता है;)

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है। यह एक शानदार जवाब है, खासकर इस साइट के लिए एक नए उपयोगकर्ता के लिए। यदि आपको किसी भी तरह की सहायता की आवश्यकता है (जिस पर मुझे संदेह है), पूछने के लिए स्वतंत्र महसूस करें

— wizzwizz4

@ wizzwizz4: हाँ, यह एक शानदार जवाब है। यह अनिवार्य रूप से खदान के समान है, सिवाय इसके कि हास्केल में इसे मेटाप्रोग्रामिंग कार्य करने के लिए एक विशेष संकलक निर्देश की आवश्यकता होती है। ;)

— मेसन व्हीलर

जब मैं जीएचसी 7.8.3 के साथ संकलन करता हूं तो मुझे "नॉट इन स्कोप: '<$>'" मिलता है (मैंने कोड सेट किया है [...].replicate (2^10)<$>[|0|]))। मैं हास्केल के साथ अनुभवी नहीं हूं; इस संकलन को बनाने के बारे में कोई संकेत?

— डेव

बहुत खराब टेम्पलेट हैस्केल एक असीम निष्पादन योग्य स्ट्रीम करने के लिए पर्याप्त आलसी नहीं है।

— PyRulez

हाय @ <$>फ़ंक्शन को हास्केल में व्यापक रूप से उपयोग किया जाता है, लेकिन केवल जीएचसी 7.10 में "प्रस्तावना" (डिफ़ॉल्ट रूप से उपलब्ध कार्यों का सेट) में स्थानांतरित किया गया था। पूर्व संस्करणों के लिए आपको import Control.Applicative;एक्साइज importस्टेटमेंट के बाद जोड़ना होगा । मैंने अभी जीएचसी 7.8.4 के साथ प्रयास किया और यह काम करता है।

— वॉरबो

Answer 5

सी ++, 250 + 26 = 276 बाइट्स

template<int A,int B>struct a{static const int n;};
template<int A,int B>const int a<A,B>::n=a<A-1,a<A,B-1>::n>::n;
template<int A>struct a<A,0>{static const int n=a<A-1,1>::n;};
template<int B>struct a<0,B>{static const int n=B+1;};
int h=a<4,2>::n;

यह टेम्पलेट्स में लागू किया गया एकरमन फ़ंक्शन है । मैं h=a<4,2>::n;अपनी छोटी (6GB) मशीन के साथ संकलन करने में सक्षम नहीं हूं , लेकिन मैंने h=a<3,14>26M आउटपुट फ़ाइल के लिए प्रबंधन किया । आप अपने मंच की सीमाओं को हिट करने के लिए स्थिरांक को ट्यून कर सकते हैं - मार्गदर्शन के लिए लिंक किए गए विकिपीडिया लेख देखें।

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

g++ -ftemplate-depth=999999 -g -c -o 69189.o 69189.cpp

प्लेटफार्म की जानकारी

g++ (Ubuntu 4.8.2-19ubuntu1) 4.8.2
Linux 3.13.0-46-generic #79-Ubuntu SMP x86_64 GNU/Linux

Comments

मुझे वास्तव में यह पसंद है, लेकिन मुझे यकीन नहीं है कि मैं एक .o आउटपुट स्वीकार कर सकता हूं, क्योंकि मैंने ईएलएफ / .exe / आदि कहा था। (और इसे पूरी तरह से अनुकूलित करने से यह सब समाप्त हो जाता है!)। फिर भी, +1 (और पुष्टि की गई)

— डेव

अपडेट: जैसा कि बेन वायगट अपने जवाब में बताते हैं, लिनक्स पर जीसीसी ईओ आउटपुट के रूप में ईएलएफ फाइलें उत्पन्न करता है , और मैं इसके साथ <3,14> वेरिएंट की पुष्टि करने में सक्षम हूं, इसलिए हाँ - यह वैध है।

— डेव

मुझे C ++ टेम्प्लेट से बाहर आने के लिए कुछ बेतुके की उम्मीद थी। मैं एकरमैन फंक्शन की उम्मीद नहीं कर रहा था ।

— मार्क

क्या फिबोनाची आपको एक छोटा कोड और बेहतर आउटपुट आकार नियंत्रण नहीं देगा?

— विल नेस

लेकिन हम बड़ा कोड चाहते हैं! फाइबोनैचि शुद्ध रेखीय कोड के रूप में लगभग समान आकार देता है (लेकिन लंबे समय तक संकलित करता है कि रैखिक)। आप निश्चित रूप से आकार का एक स्थिर सरणी के साथ मजा कर सकता है A+Bप्रत्येक वर्ग में, अब मैं इसके बारे में लगता है ...

— टोबी स्पीट

Answer 6

एएसएम, 61 बाइट्स (29 बाइट्स स्रोत, झंडे के लिए 32 बाइट्स), 4,294,975,320 बाइट्स निष्पादन योग्य

.globl main
main:
.zero 1<<32

संकलन gcc the_file.s -mcmodel=large -Wl,-fuse-ld=gold

Comments

1<<30सी के लिए पर्याप्त अच्छा है क्योंकि यह कोडांतरक है, आकार बाइट्स में है।

— विराटपुर

@viraptor मेरे सिस्टम में 32GB RAM है और kicks के लिए मैंने आपका कोड बनाने की कोशिश की है। asप्रबंधन करने के लिए बंद है ld, लेकिन इस केld साथ विफल रहता है । मदद भी नहीं लगती। -mcmodel=medium

— इव्लोनटेक्सिस्ट इडोनाटेक्सिस्ट

goldलिंकर के उपयोग के लिए मजबूर करने का प्रयास करें : gcc -fuse-ld=gold ...संकलन / लिंक ... eek! 1:29 (89 सेकंड) में समाप्त और 1,073,748,000 बाइट्स का आकार।

— लोर्निक्स

अंत में मुझे 64-बिट उबंटू 15.10 पर असेंबल करने के लिए मिला gcc -o g g.s -mcmodel=large -Wl,-fuse-ld=gold। अंतिम मिलान: 4,294,975,320 bytes32 अतिरिक्त बाइट्स के साथ कार्यक्रम की लंबाई के लिए जोड़ा गया -mcmodel=large -Wl,-fuse-ld=gold। यह ध्यान देने योग्य है कि हेडर गलत है; स्रोत 29 बाइट्स है (अतिरिक्त झंडे जोड़े बिना)।

— Mego

आवंटन को टक्कर देकर 1<<33, मैं एक 8,589,942,616बाइट निष्पादन योग्य के साथ समाप्त हुआ ।

— मेघो

Answer 7

यहाँ 2005 से मेरा C उत्तर है। यदि आप 16TB RAM (आप नहीं) करते हैं तो 16TB बाइनरी का उत्पादन करेगा।

struct indblock{
   uint32_t blocks[4096];
};

struct dindblock {
    struct indblock blocks[4096];
};

struct tindblock {
    struct dindblock blocks[4096];
};

struct inode {
    char data[52]; /* not bothering to retype the details */
    struct indblock ind;
    struct dindblock dint;
    struct tindblock tind;
};

struct inode bbtinode;

int main(){}

Comments

"यदि आप 16TB RAM (आप नहीं है) एक 16TB बाइनरी का उत्पादन करेंगे।" - न तो मेरे पास एक 16TB हार्ड ड्राइव है! मैं वास्तव में इसे सत्यापित नहीं कर सकता, लेकिन फिर भी यह शांत है।

— डेव

मैंने इसे दुर्घटना से खोजा और पता स्थान से बाहर निकलने पर कंपाइलर को ऊपर से देखा।

— जोशुआ

कृपया इस प्रविष्टि के लिए प्रयास न करें; गोल्फिंग कोड नमूने के इरादे को हरा देता है और ऐसा करने के लिए कोई स्कोर लाभ नहीं हैं। कोड पहले से ही 2005 की GPL'd है।

— यहोशू

@BenVoigt भले ही, अन्य लोगों के कोड को संपादित करना यहाँ कभी स्वीकार्य नहीं है। यदि कोई समस्या है तो एक टिप्पणी छोड़ दें। प्रासंगिक मेटा पोस्ट: meta.codegolf.stackexchange.com/questions/1615/...

— Mego

@ जोशुआ: मार्कडाउन अंतर की जांच करें। Mego ने केवल हाइलाइटिंग संकेत को जोड़ा।

— n --h'a̷̭̿h̸̡̅ẗ̵̨́d̷̰̀ĥ̷̳

Answer 8

सादा पुराना सी प्रीप्रोसेसर: 214 बाइट्स इनपुट, 5 एमबी आउटपुट

मेरी वास्तविक दुनिया से प्रेरित होकर यहां असफल होना ।

#define A B+B+B+B+B+B+B+B+B+B
#define B C+C+C+C+C+C+C+C+C+C
#define C D+D+D+D+D+D+D+D+D+D
#define D E+E+E+E+E+E+E+E+E+E
#define E F+F+F+F+F+F+F+F+F+F
#define F x+x+x+x+x+x+x+x+x+x

int main(void) { int x, y = A; }

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

Comments

यह एक xml बम की तरह है

— एक कान की बाली

विशेष रूप से यह मूल "बिलियन लाफ्स" का कार्यान्वयन है।

— मइंक्सोमा

यह सरल अभी तक पागल है।

— वाहिद अमीरी

वाह, यह वास्तव में जीसीसी 4.9 और क्लैंग में सेगफॉल्ट का कारण बनता है। आपने कौन सा कंपाइलर इस्तेमाल किया?

— डेव

@ डव: अजीब। जब मैं मेक यूज़ करता हूं, तो यह कंपाइल करता है, लेकिन अगर मैं सटीक उसी कमांड में टाइप करता हूं जो उपयोग करता है, तो यह क्रैश हो जाता है। और यह पर्यावरण चर से संबंधित नहीं लगता है।

— थॉमस पैड्रॉन-मैक्कार्थी

Answer 9

जावा, 450 + 22 = 472 बाइट्स स्रोत, ~ 1 जीबी क्लास फ़ाइल

B.java (गोल्फ संस्करण, संकलन के दौरान चेतावनी)

import javax.annotation.processing.*;@SupportedAnnotationTypes("java.lang.Override")public class B extends AbstractProcessor{@Override public boolean process(java.util.Set a,RoundEnvironment r){if(a.size()>0){try(java.io.Writer w=processingEnv.getFiler().createSourceFile("C").openWriter()){w.write("class C{int ");for(int i=0;i<16380;++i){for(int j=0;j<65500;++j){w.write("i");}w.write(i+";int ");}w.write("i;}");}catch(Exception e){}}return true;}}

बी.जेवा (अनगुल्ड संस्करण)

import java.io.Writer;
import java.util.Set;

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.annotation.processing.SupportedAnnotationTypes;
import javax.annotation.processing.SupportedSourceVersion;
import javax.lang.model.SourceVersion;
import javax.lang.model.element.TypeElement;

@SupportedAnnotationTypes("java.lang.Override")
@SupportedSourceVersion(SourceVersion.RELEASE_8)
public class B extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        if (annotations.size() > 0) {
            try (Writer writer = processingEnv.getFiler().createSourceFile("C").openWriter()) {
                writer.write("class C{int ");
                for (int i = 0; i < 16380; ++i) {
                    for (int j = 0; j < 65500; ++j) {
                        writer.write("i");
                    }
                    writer.write(i + ";int ");
                }
                writer.write("i;}");
            } catch (Exception e) {
            }
        }
        return true;
    }
}

संकलन

javac B.java
javac -J-Xmx16G -processor B B.java

व्याख्या

यह बम एनोटेशन प्रोसेसर्स का उपयोग करता है। इसके लिए 2 संकलन पास चाहिए। पहला पास प्रोसेसर क्लास बनाता है B। दूसरे पास के दौरान प्रोसेसर एक नया स्रोत फ़ाइल बनाता है C.java, और इसे बाइट्स के C.classआकार के साथ संकलित करता है 1,073,141,162।

बड़ी श्रेणी की फ़ाइल बनाने का प्रयास करते समय कई सीमाएँ होती हैं:

• पहचानकर्ता से में 64k के बारे में परिणाम अब बनाना: error: UTF8 representation for string "iiiiiiiiiiiiiiiiiiii..." is too long for the constant pool।
• लगभग 64k से अधिक चर / कार्य परिणाम बनाना: error: too many constants
• किसी फ़ंक्शन के कोड आकार के लिए लगभग 64k की सीमा भी है।
• .classफ़ाइल के लिए लगभग 1GB के जावा कंपाइलर में एक सामान्य सीमा (बग?) लगती है । यदि मैं उपरोक्त कोड में वृद्धि 16380करता हूं 16390तो संकलक कभी नहीं लौटता है।
• .javaफ़ाइल के लिए लगभग 1GB की सीमा भी है । बढ़ाने से 16380करने 16400में उपरोक्त कोड परिणामों में: An exception has occurred in the compiler (1.8.0_66). Please file a bug ...एक के बाद java.lang.IllegalArgumentException।

Comments

साफ; आपने अनिवार्य रूप से अपना स्वयं का प्रीप्रोसेसर बनाया है, आकार सीमा के भीतर, एक कंपाइलर के साथ एक भाषा में जो मूल रूप से कस्टम प्रीप्रोसेसर का समर्थन करता है। यह नियमों के भीतर है। मेरे लिए अंतिम वर्ग केवल 0.5GB था, लेकिन मैं विधि की पुष्टि कर सकता हूं।

— डेव

जावा में एक और उदाहरण habrahabr.ru/post/245333 - यह नेस्टेड का उपयोग करता है try..finally(अंत में ब्लॉक को सामान्य और असाधारण मामलों के लिए दोहराया जाता है) और इनिशलाइज़र ब्लॉक (इनिशियल ब्लॉक से कोड प्रत्येक कंस्ट्रक्टर को जोड़ा जाता है)

— विक्टर

मैं प्रतिस्थापित äएक से iऔर संख्या समायोजित। अब बम को किसी भी एन्कोडिंग मुद्दों के बिना किसी भी सिस्टम पर 1GB वर्ग बनाना चाहिए। हालाँकि, इसे अब और अधिक मेमोरी की आवश्यकता है।

— स्लिफ़र

? TypeElement को विस्तारित करता है?

— बिल्ली

— @cat

Answer 10

सी, 26 बाइट स्रोत, 2,139,103,367 बाइट आउटपुट, वैध कार्यक्रम

const main[255<<21]={195};

संकलित का उपयोग कर: gcc cbomb.c -o cbomb(gcc संस्करण 4.6.3, Ubuntu 12.04, ~ 77 सेकंड)

मैंने सोचा कि मैं यह देखने की कोशिश करूंगा कि बिना किसी कमांड लाइन विकल्पों का उपयोग किए मैं कितना बड़ा वैध कार्यक्रम बना सकता हूं। मुझे इस उत्तर से विचार मिला: https://codegolf.stackexchange.com/a/69193/44946 डिजिटल ट्रामा द्वारा। टिप्पणियों को देखें कि यह क्यों संकलित है।

यह कैसे काम करता है: constखंड में पृष्ठों से लेखन ध्वज को हटाता है, इसलिए मुख्य निष्पादित किया जा सकता है। 195एक वापसी के लिए इंटेल मशीन कोड है। और चूंकि Intel आर्किटेक्चर थोड़ा-सा एंडियन है, इसलिए यह पहला बाइट है। यह प्रोग्राम ईएक्स रजिस्टर में डाले गए स्टार्ट अप कोड के साथ बाहर निकल जाएगा, संभावित 0।

यह केवल 2 टमटम के बारे में है क्योंकि लिंकर ऑफ़सेट के लिए 32 बिट हस्ताक्षरित मूल्यों का उपयोग कर रहा है। यह 2 मेगाबाइट से 8 मेगा छोटा है क्योंकि कंपाइलर / लिंकर को काम करने के लिए कुछ जगह की आवश्यकता होती है और यह सबसे बड़ी है जिसे मैं लिंकर त्रुटियों के बिना प्राप्त कर सकता था - ymmv।

Comments

एक तरफ दिलचस्प के रूप में, उत्पादन 2,078,451 बाइट अधिकतम संपीड़न = 1029: 1 संपीड़न अनुपात के साथ gziped है।

— जकिपु

Answer 11

बू , 71 बाइट्स। संकलन समय: 9 मिनट। 134,222,236 बाइट निष्पादन योग्य

macro R(e as int):
 for i in range(2**e):yield R.Body
x = 0
R 25:++x

Rसंकलक के बयान को मनमाने ढंग से गुणा करने के लिए संकलक के कारण मैक्रो (बार-बार) का उपयोग करता है । कोई विशेष संकलक झंडे की आवश्यकता नहीं है; बस के रूप में फ़ाइल को बचाने के लिए bomb.booऔर booc bomb.booइसे बनाने के साथ संकलक आह्वान ।

Comments

2**e-यह क्या है? कोशिश करो 9**e!

— वचर्गिन १३'१६

@Chargin: मेटाप्रोग्रामिंग के बारे में मजेदार बात यह है कि आप इसे कितनी आसानी से अनुकूलित कर सकते हैं!

— मेसन व्हीलर

मुझे बू स्थापित करने में थोड़ी परेशानी हो रही है ... जब मैं इसे स्थापित करने का प्रबंधन करता हूं तो मैं इसकी पुष्टि करता हूं!

— डेव

@ क्या आपको इससे परेशानी हो रही है?

— मेसन व्हीलर

Answer 12

कोटलिन , 90 बाइट्स स्रोत, 177416 बाइट्स (173 KB) ने JVM बाइनरी संकलित किया

inline fun a(x:(Int)->Any){x(0);x(1)}
fun b()=a{a{a{a{a{a{a{a{a{a{a{println(it)}}}}}}}}}}}

तकनीकी रूप से, आप इसे आगे अभिव्यक्ति को समाप्त करके और भी लंबा बना सकते हैं। हालाँकि, StackOverflowयदि आप पुनरावर्तन को बढ़ाते हैं , तो कंपाइलर एक त्रुटि के साथ क्रैश होता है ।

Comments

आपके SI उपसर्ग सहमत नहीं हैं। क्या वह 177416 किलोबाइट = 173 एमबी या 177416 बाइट = 173 केबी है?

— बेन वोइगट

@BenVoigt आपको इंगित करने के लिए धन्यवाद: D

— TheNumberOne

प्रभावशाली, एक +1

— जे एटकिन

कोटलिन 1.2.20 के संकलन के लिए हमें एक गहराई निकालने की आवश्यकता है और यह ~ 104kB है। आपने मूल रूप से किस संस्करण का उपयोग किया था?

— ट्वीस्टरेब

Answer 13

C ++, 214 बाइट्स (कोई विशेष संकलन विकल्प की आवश्यकता नहीं)

#define Z struct X
#define T template<int N
T,int M=N>Z;struct Y{static int f(){return 0;}};T>Z<N,0>:Y{};T>Z<0,N>:Y{};T,int M>Z{static int f(){static int x[99999]={X<N-1,M>::f()+X<N,M-1>::f()};}};int x=X<80>::f();

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

g++ 4.9.3 x86_64-pc-cygwin2567355421 बाइट्स (2.4GiB) के साथ जेनरेट की गई ऑब्जेक्ट फाइल ।

80 से ऊपर प्रारंभिक मूल्य में वृद्धि से साइबरविन जीसीसी असेंबलर (बहुत सारे सेगमेंट) टूट जाते हैं।

इसके अलावा, स्रोत कोड को बदलने के बिना बढ़े हुए आकार के लिए या समान 99999द्वारा प्रतिस्थापित किया जा सकता है 9<<19... लेकिन मुझे नहीं लगता कि मुझे पहले से कहीं अधिक डिस्क स्थान का उपयोग करने की आवश्यकता है;)

Comments

पुष्टि की गई (वास्तव में, यह 2.56GB क्लैंग के साथ है), लेकिन इसे -cलिंकर (2 अतिरिक्त बाइट्स) को रोकने के लिए एक संकलित ध्वज की आवश्यकता है , और मुझे यकीन नहीं है कि मैं स्वीकार कर सकता हूं। मैं आउटपुट (मेरे द्वारा सूचीबद्ध एक नहीं)। फिर भी, मुझे यह पसंद है, इसलिए +1।

— डेव

@ क्या: gcc .o फाइलें ELF स्वरूप की हैं?

— बेन वोइग्ट

निश्चित नहीं। जब मैं उन्हें उत्पन्न करता हूं तो वे ईएलएफ मैजिक नंबर से शुरू नहीं होते ... मैं बाद में जांच करूंगा।

— डेव

@ क्या: ठीक है, cygwin gcc एक ELF फ़ाइल नहीं बना रहा है। लिनक्स gcc लगता है (हालाँकि मैं एक अलग कोड से देख रहा हूँ)

— बेन Voigt

हां, कुबंटु पर जीसीसी 5.2.1 वास्तव में एक ईएलएफ फ़ाइल उत्पन्न कर रहा है, लेकिन यह केवल 9 एमबी है! यकीन नहीं है कि यह अन्य कंपाइलरों की तुलना में इसे कैसे संपीड़ित करने में कामयाब है। शायद GCC 4.9 एक 2GB ELF फ़ाइल बनायेगी।

— डेव

Answer 14

स्केल - 70 बाइट स्रोत, 22980842 बाइट परिणाम (जार के बाद)

import scala.{specialized => s}
class X[@s A, @s B, @s C, @s D, @s E]

यह ९ ^५ (लगभग ^५ ९ ०००) विशेष श्रेणी की फाइलें तैयार करता है, जो लगभग २३ एमबी के जार में पैक होती है। आप सिद्धांत रूप में जा सकते हैं यदि आपके पास एक फाइलसिस्टम है जो कि कई फाइलों और पर्याप्त मेमोरी को संभाल सकता है।

(यदि जार कमांड को शामिल किया जाना चाहिए, तो यह 82 बाइट्स है।)

Comments

मैं इसे संकलित नहीं कर सका error: java.lang.OutOfMemoryError: GC overhead limit exceeded:। क्या आप संकलन के लिए आवश्यक कमांड का भी दस्तावेज बना सकते हैं?

— P.Péter

@ P.Péter - आपको संकलक को अधिक मेमोरी देने की आवश्यकता है, उदाहरण scalac -J-Xmx12G X.scalaके लिए मैंने क्या उपयोग किया है। मैंने परीक्षण नहीं किया कि वास्तव में इसकी कितनी आवश्यकता है।

— रेक्स केर

अभी भी संकलित नहीं, दुख की बात है :( error: error while loading AnnotatedElement, class file '/usr/lib/jvm/java-8-openjdk-amd64/jre/lib/rt.jar(java/lang/reflect/AnnotatedElement.class)' is broken (bad constant pool tag 18 at byte 76) one error foundक्या आप स्काला और जावा संस्करण (शायद प्लेटफ़ॉर्म, भी) निर्दिष्ट कर सकते हैं? मैंने स्केल 8 का उपयोग किया। 2.9.2 और ओपनजेडके 1.8.0_66-आंतरिक-बी 17, डेबियन 8 x86-64 पर

— P.Péter

उबंटू 15.10, java version "1.8.0_72-ea" Java(TM) SE Runtime Environment (build 1.8.0_72-ea-b05) Java HotSpot(TM) 64-Bit Server VM (build 25.72-b05, mixed mode) ,$ scala -version Scala code runner version 2.11.7 -- Copyright 2002-2013, LAMP/EPFL

— रेक्स केर

Answer 15

सी, 284 बाइट्स + 2 के लिए -cमें gcc bomb.c -o bomb.o -c; आउटपुट: 2 147 484 052 बाइट्स

#define a 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
#define b a,a,a,a,a,a,a,a,a,a,a,a,a,a,a,a
#define c b,b,b,b,b,b,b,b,b,b,b,b,b,b,b,b
#define d c,c,c,c,c,c,c,c,c,c,c,c,c,c,c,c
#define e d,d,d,d,d,d,d,d,d,d,d,d,d,d,d,d
#define f e,e,e,e,e,e,e,e,e,e,e,e,e,e,e,e
__int128 x[]={f,f,f,f,f,f,f,f};

Answer 16

बू, जिस तरह से आप इससे अधिक उम्मीद कर सकते हैं

macro R(e as int):for i in range(9**e):yield R.Body
x = 0
R 99:++x

Comments

यह कुछ छोटे परिवर्तनों (??) के साथ मेसन व्हीलर के जवाब की तरह दिखता है। क्या आप स्वतंत्र रूप से उसी उत्तर तक पहुँच गए हैं या आपके द्वारा बदले गए मूल्यों में कुछ महत्वपूर्ण है (यदि ऐसा है, तो कृपया यह समझाने के लिए कि वे क्यों महत्वपूर्ण हैं इसका उत्तर संपादित करें)।

— डेव

Answer 17

पायथन 3:

9**9**9**9**9

टेट्रेशन बम

Comments

आपको यह संकेत करना चाहिए कि आउटपुट कितने बाइट्स है, यह देखने के लिए कि आपकी प्रविष्टि दूसरों से कैसे तुलना करती है।

— सेंचुरी

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

— मार्टिन एंडर

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

— डेव