सबसे छोटा प्रोग्राम जो लगातार मेमोरी आवंटित करता है

49

एक प्रोग्राम लिखें जो हमेशा के लिए चलता है और ढेर पर अधिक से अधिक मेमोरी आवंटित करता है जितना अधिक समय तक चलता है, कम से कम जब तक आप ऑपरेटिंग सिस्टम की सीमा तक नहीं पहुंचते हैं जो स्मृति आवंटित की जा सकती है।

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

सबसे छोटा कोड जीतता है।

code-golf 
— tbodt
स्रोत
13
क्या स्टैक एक वैध समाधान है? क्या मेमोरी को लीक करना है या सिर्फ आवंटित करना है?
— गेहूं जादूगर
1
@HeatWizard मेमोरी को लीक होने की ज़रूरत नहीं है, लेकिन इसे डील-डौल किए जाने की तुलना में तेज़ी से आवंटित किया जाना है।
— tbodt
2
एक बार जब मैं चाहता हूं कि मेरा कार्यक्रम अनंत स्मृति का उपभोग करे, तो मैं इसे प्राप्त नहीं कर सकता। (reduce conj [] (range))(क्लोजर) 737mb तक हो जाता है, फिर बस बढ़ना बंद हो जाता है। Idk कैसे यह लगातार ऊपर नहीं जा रहा है। यह "सोचता है" मैं पूरी सूची को अंत में प्रिंट करना चाहता हूं, इसलिए इसे कुछ भी फेंकना नहीं चाहिए। अधिक निराश।
— कैरिजनेट
14
स्वयं पर ध्यान दें: परीक्षण से पहले कोड सहेजें। मेम-लीक का परिचय IDE दुर्घटनाग्रस्त कर सकता है ...
— steenbergh
1
मुझे लगता है कि आपको इसी तरह की एक और गोल्फ चुनौती को जोड़ना चाहिए, लेकिन इसके लिए अलग से प्रोग्राम की आवश्यकता होती है, जो समय के रैखिक कार्य की तुलना में मेमोरी को तेजी से खपत करता है। के लिए वर्तमान चुनौती, हमेशा के लिए पाशन और एक एकल बाइट आवंटन ठीक होना चाहिए। आपकी नई चुनौती के लिए, यह अपर्याप्त होगा, लेकिन हमेशा के लिए लूपिंग और हर बार उपयोग की जाने वाली मेमोरी की मात्रा को दोगुना करना ठीक होगा।
— बेनगोल्डबर्ग

जवाबों:

46

फंज -98 ( cfunge), 1 बाइट

9

मैंने इसे पहले ही पोस्ट कर दिया था, लेकिन इसका परीक्षण करने का निर्णय लिया, और मेरे कंप्यूटर को एक उपयोगी स्थिति में वापस लाने में थोड़ा समय लगा। cfungeऑपरेटिंग सिस्टम के ढेर पर फंज स्टैक को स्टोर करता है (जो कि एक छोटी मेमोरी सीमा के साथ प्रोग्राम को चलाकर आसानी से सत्यापित हो जाता है, कुछ ऐसा जो मुझे पहले करना चाहिए था!), इसलिए एक असीम रूप से बढ़ते स्टैक (इस प्रोग्राम के साथ, जो सिर्फ 9बार-बार धक्का देता है ; फ़ॉन्ग प्रोग्राम्स एक पंक्ति के अंत से डिफ़ॉल्ट रूप से प्रारंभ तक लपेटते हैं) हमेशा के लिए मेमोरी आवंटित करेंगे। इस कार्यक्रम की संभावना कुछ बेफुज -93 कार्यान्वयन में भी काम करती है।

अधिक दिलचस्प:

"NULL #(4

यह मेरा पहला विचार था, और एक अनंत आवंटन है जो फ़ंज स्टैक पर निर्भर नहीं करता है (हालांकि यह फ़न स्टैक को भी उड़ा देता है)। इसके साथ शुरू करने के लिए, "कमांड बाकी प्रोग्राम की एक प्रति को स्टैक पर ले जाता है (यह एक स्ट्रिंग है, और प्रोग्राम राउंड लपेटता है, इसलिए करीबी उद्धरण खुले उद्धरण के रूप में भी कार्य करता है)। तब Nपरिलक्षित होता है (इसका डिफ़ॉल्ट रूप से कोई अर्थ नहीं है), जिससे प्रोग्राम पीछे की ओर चला जाता है। "फिर से रन, और ढेर करने के लिए कार्यक्रम धक्का - साथ अन्य तरह इस बार दौर, Nतो कार्यक्रम, इर्द-गिर्द घूमती एक 4 अक्षर का नाम (के साथ एक पुस्तकालय लोड हो रहा है - ढेर के शीर्ष पर 4(, NULLपुस्तकालय का हिस्सा है cfungeमानक पुस्तकालय)। NULLपरिलक्षित करने के लिए सभी बड़े अक्षरों को परिभाषित करता है, इसलिए Lपरिलक्षित होता है,#रास्ते में पुस्तकालय के लोड को छोड़ देता है, 4रद्दी को धक्का देता है जिसे हम स्टैक की परवाह नहीं करते हैं और पूरा कार्यक्रम शुरू से दोहराता है। यह देखते हुए कि किसी लाइब्रेरी को कई बार लोड करने का प्रभाव पड़ता है, और लाइब्रेरी की प्रत्येक कॉपी के लिए लाइब्रेरी की कमांड लिस्ट को एक बार स्टोर करने की आवश्यकता होती है (यह फंज -98 के शब्दार्थ द्वारा निहित है), यह नॉन-स्टैक स्टोरेज के माध्यम से मेमोरी लीक करता है (जो कि एक है "हीप" को परिभाषित करने का वैकल्पिक तरीका, ओएस के बजाय भाषा के सापेक्ष)।

2
मैं बस इसे स्वीकार करने जा रहा हूं ...
— tbodt
क्या संख्या 9 होना आवश्यक है? यह भी काम करेगा अगर यह 5 था?
— tbodt 19
कुछ भी जो स्टैक कार्यों को धक्का देता है (संभवतः को छोड़कर 0; यह संभव है कि फ़ंज़ कार्यान्वयन या ओएस को उस ऑप्टिमाइज़ करने का एक तरीका मिल सके, यह देखते हुए कि प्रश्न में मेमोरी पहले से ही शून्य से भरा है)। मैंने सिर्फ 9मनमानी की।
22
अस्वीकार्य है क्योंकि मैं चाहता हूं कि मेरी प्रतिष्ठा अभी भी 666 हो।
— tbodt
7
@tbodt स्वीकार न करने का वास्तविक कारण नहीं। यदि आप चाहें, तो मैं -1 सवाल करूंगा। फिर जब आप स्वीकार करते हैं, तो आपके पास 703 होगा (ध्यान दें कि आपके पास अब 703 है, 666 नहीं)।
— NoOneIsHere
30

ब्रेनफक, 5 बाइट्स

+[>+]

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

— vsz
स्रोत
2
मुझे पूरा यकीन है कि यह + [> +] है वरना यह पहले पुनरावृत्ति पर ही रुक जाता। ;)
— पेरी डौडी
आप सही हैं, टाइपो के लिए क्षमा करें।
— vsz
40
दुर्लभ समय में से एक जहां दिमागी हल प्रतिस्पर्धात्मक है ...
— 19
@ Flp.Tkc लेकिन यह अभी भी खो देता है। शायद यह किसी दिन जीत जाएगा ...
— NoOneIsHere
6
@SeeOneRhino: यह पहले से ही एक बार जीत गया, सभी गोल्फ भाषाओं को हराकर> codegolf.stackexchange.com/questions/8915/…
— vsz
22

बैश + कोरुटिल्स, 5

या

रूबी, ५

`yes`

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

यह इंगित करने के लिए @GB का धन्यवाद रूबी में एक बहुभुज है।

— डिजिटल आघात
स्रोत
7
मैं उसी को लिखने वाला था और इसे रूबी प्रोग्राम कहता था।
— जीबी
1
और मैं सोचता हूं।
— 12
18

पायथन, 16 बाइट्स

aएक त्रुटि तक पहुंचने तक घोंसला बनाए रखता है:

a=0
while 1:a=a,

पहले कुछ पुनरावृत्तियों (टुपल्स के रूप में) इस तरह दिखते हैं:

0
(0,)
((0,),)
(((0,),),)

इत्यादि इत्यादि।

— FlipTack
स्रोत
18

> <> (मछली), 1 बाइट

0

यहाँ कोशिश करो!

0 वास्तव में किसी भी हेक्साडेसिमल नंबर 1-एफ के लिए प्रतिस्थापित किया जा सकता है।

व्याख्या

0> में <> बस मछली को तैरने के लिए एक 1x1 कोडबॉक्स बनाता है। यह लगातार 0स्टैक पर जोड़ता है , दाएं तैरता है, जो पीछे की ओर छोरों को जोड़ता है 0, इसे फिर से स्टैक में जोड़ता है। यह हमेशा के लिए चला जाएगा।

— redstarcoder
स्रोत
2
अब मैं सोच रहा हूँ कि यह कितनी अन्य 2-आयामी भाषाओं में काम करता है। उनमें से अधिकांश स्टैक-आधारित हैं, आखिरकार।
1
क्यूबिक्स में लगभग काम करता है , लेकिन इसे निष्पादन की रेखा में .स्थानांतरित करने के लिए एक अग्रणी (या किसी भी गैर-व्हाट्सएप चार) की आवश्यकता होती है 0।
— ETHproductions 20
1
ऑरोबोरोस में काम करता है , लेकिन उसी तरह से नहीं: दुभाषिया 0000000...एक पूर्णांक शाब्दिक के रूप में पढ़ने की कोशिश करता है , और यह जो स्ट्रिंग बनाता है वह अधिक मेमोरी लेता है। एक प्रोग्राम जो इस तरह से काम करता है वह होगा a(10 असीम रूप से धक्का देता है)।
— DLosc
12

जावा 101 बाइट्स

class A{public void finalize(){new A();new A();}public static void main(String[]a){for(new A();;);}}

एक वस्तु बनाने और फेंकने के बाद एक अंतहीन लूप में मुख्य कार्यक्रम को पकड़ना। कचरा संग्रह प्रत्येक हटाए गए लोगों के लिए 2 ऑब्जेक्ट बनाकर लीक करने का काम करता है

— masterX244
स्रोत
खैर मैं स्पष्ट के साथ नहीं जा रहा के लिए थोड़ा मूर्खतापूर्ण लगता है, हाहा। मैं यह कहने के लिए उद्यम करूंगा कि यह मेरी तुलना में अधिक सुरुचिपूर्ण है
— पोक
1
हाँ, आपके कोड ने फाइनली () @poke
— masterX244
मुझे लगता है कि आप स्थैतिक इनिशियलाइज़र के साथ मुख्य की जगह इसे छोटा बना सकते हैं
— tbodt
केवल
— java6
2
रिसाव का कारण बनने के लिए कचरा संग्रहकर्ता का उपयोग करना! महान विचार :)
— मार्क के कोवान
12

पर्ल, 12 बाइट्स

{$"x=9;redo}

पर्ल में, xऑपरेटर बाईं ओर एक स्ट्रिंग और दाईं ओर एक नंबर के साथ, एक दोहराया स्ट्रिंग पैदा करता है। इसलिए "abc" x 3मूल्यांकन करता है "abcabcabc"।

x=ऑपरेटर बाईं तर्क mutates, दोहरा यह सामग्री रूप में कई बार के रूप में अपने दाहिने हाथ की ओर इंगित करता है का परिणाम के साथ अपने बाईं तरफ चर की सामग्री की जगह।

पर्ल में कई अजीब तरह के नाम से निर्मित चर हैं, जिनमें से एक है $", जिसका प्रारंभिक मूल्य एक एकल स्थान है।

redoऑपरेटर संलग्न की शुरुआत करने के लिए कूदता है {}।

पहली बार x=ऑपरेटर किया जाता है, यह " $"से " "" के मान को बदलता है " ", जो 9 रिक्त स्थान है।

दूसरी बार जब x=ऑपरेटर किया जाता है, तो इसका मान बदल $"जाता है " ", जो कि 81 स्थान है।

तीसरी बार, $"729 बाइट्स की लंबी स्ट्रिंग बन जाती है।

मुझे लगता है कि आप देख सकते हैं कि यह कहाँ जा रहा है :)।

— BenGoldberg
स्रोत
आपने मुझे इसमें हरा दिया! और तुम्हारा तीन बाइट्स छोटा है।
— गेब्रियल बेनामी
1
यह सबसे छोटी पाश के लिए इस वेब साइट को खोजने का मामला था :)। इसके अलावा, मैं शुरू $_.=7में अपने पाश में था, लेकिन एहसास हुआ कि अगर मैं इसका इस्तेमाल कर सकता हूं तो x=यह बहुत तेजी से स्मृति से बाहर चला जाएगा, और फिर perldoc perlvarकुछ उपयुक्त लेने के लिए दौड़ा ।
— बेनगोल्डबर्ग
{$^O++;redo}जब ^Oएक एकल chr(15)बाइट होती है तो एक बाइट कम होती है । यद्यपि यह MUCH धीमी दर पर मेमोरी को बेकार कर देगा - एक बाइट को बर्बाद करने के लिए विंडोज पर 1000000000 पुनरावृत्तियों की आवश्यकता होती है। किसी भी OS पर काम करेंगे जिसका नाम लैटिन अक्षर में शुरू हो।
— ओलेग वी। वोल्कोव
11

सीड, 5 बाइट्स

golfed

H;G;D

उपयोग (कोई भी इनपुट करेगा)

sed 'H;G;D' <<<""

व्याख्या की

#Append a newline to the contents of the hold space, 
#and then append the contents of the pattern space to that of the hold space.
H

#Append a newline to the contents of the pattern space, 
#and then append the contents of the hold space to that of the pattern space. 
G

#Delete text in the pattern space up to the first newline, 
#and restart cycle with the resultant pattern space.
D

स्क्रीनशॉट

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

यह ऑनलाइन की कोशिश करो!

— टसेपेल्लिन
स्रोत
2
यह स्पष्ट रूप से बात कर रहा है कि यह GNU sed (अर्धविराम मानक सेड नहीं है) लेकिन एक नई पंक्ति वैसे भी अर्धविराम ही काम करेगी।
— आर ..
10

हास्केल, 23 19 बाइट्स

main=print$sum[0..]

अनंत सूची का योग प्रिंट करें

— Angs
स्रोत
यह मूल्यांकन लागू करने का एक अच्छा तरीका है, और यह बहुत कॉम्पैक्ट भी है। +1
— फल तोड़ना
एक संकलक बहुत अच्छी तरह से इसे O (1) मेमोरी में चला सकता है। जीएचसी में, sumके रूप में परिभाषित किया गया है foldl (+) 0, और थैंक ब्लो-आउट को रोकने के लिए सख्ती से विश्लेषण को रोकने के लिए क्या करना है? क्या आपने इसे अनुकूलन के साथ संकलित किया था?
— विल नेस
@WillNess जवाब क्या हो सकता है? sumपहले से पता नहीं होगा कि सूची अनंत है और printयोग के लिए पहले इसका मूल्यांकन किया जाना चाहिए। और हाँ, मैंने इसे अनुकूलन के साथ संकलित किया
— Angs
कोई उत्तर नहीं होगा; लेकिन गणना O (1) स्थान में चलेगी। उफ़, हड़ताल करें, क्योंकि डिफ़ॉल्ट करने के कारण Integer, संख्याएँ अबाधित हैं और bignum वर्तमान परिणाम द्वारा ली गई मेमोरी , वास्तव में बढ़ेगी।
— विल नेस
1
बस स्पष्ट करने के लिए, मेरा क्या मतलब था कि sum xs = foldl (+) 0 xsकिसी स्थिर लूप की गणना निरंतर स्टैक में चल सकती है । foldl' (+) 0 xsनिश्चित रूप से होगा। तो कुछ के लिए स्मृति आवंटित करने वाली एकमात्र चीज, द्विगुण अंतरिम परिणाम है।
— विल नेस
9

सी ++ (जी ++ संकलक का उपयोग करके), 27 23 15 बाइट्स

4 बाइट निकालने में मेरी मदद करने के लिए Neop को धन्यवाद

यह समाधान वास्तव में किसी भी मेमोरी को लीक नहीं करता है क्योंकि यह स्टैक पर सब कुछ आवंटित करता है और इस तरह स्टैक ओवरफ्लो का कारण बनता है। यह बस असीम रूप से पुनरावर्ती है। जब तक स्टैक ओवरफ्लो नहीं हो जाता तब तक प्रत्येक पुनरावृत्ति कुछ स्मृति को आवंटित करने का कारण बनती है।

main(){main();}

दूसरा तरीका

यह समाधान वास्तव में स्मृति को लीक करता है।

main(){for(;;new int);}

वेलग्रिंड आउटपुट

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

==2582== LEAK SUMMARY:
==2582==    definitely lost: 15,104,008 bytes in 3,776,002 blocks
==2582==    indirectly lost: 0 bytes in 0 blocks
==2582==      possibly lost: 16 bytes in 4 blocks
==2582==    still reachable: 4 bytes in 1 blocks
==2582==         suppressed: 0 bytes in 0 blocks
— गेहूं का जादूगर
स्रोत
3
शीर्षक भ्रामक है; प्रश्न कहता है "एक प्रोग्राम लिखें जो हमेशा के लिए चलता है और लगातार मेमोरी आवंटित करता है।"
— नादाद
जब मैंने खदान भेजा तो ओह मुझे एहसास नहीं हुआ कि आपने पहले ही जवाब दे दिया है।
— 3
1
@ अच्छी तरह से मुझे नहीं पता था कि int जब तक मैंने आपका धन्यवाद नहीं देखा , तब तक आप नहीं कर सकते !
— गेहूं जादूगर
2
नहीं C++, बस जी ++ की बोली: सी ++ मना करने वाले मुख्य; C ++ को int main...घोषणा की आवश्यकता है । लेकिन समाधान अभी भी साफ है :-)
— मार्टिन बा
1
दरअसल, C ++ ने कॉलिंग को मना किया है main।
— आर ..
9

जावा, 81 79 78 बाइट्स

जावा (हॉटस्पॉट) 71 70 बाइट्स

मेरे द्वारा पोस्ट किए गए समय में अन्य जावा उत्तरों की तुलना में कम (81, बाद में 79 बाइट्स):

class A{public static void main(String[]a){String x="1";for(;;)x+=x.intern();}}

जैसा कि @Olivier Grégoire ने सुझाव दिया है, एक और बाइट को बचाया जा सकता है:

class A{public static void main(String[]a){for(String x="1";;)x+=x.intern();}}

x+=x.intern()लूप वेतन वृद्धि के रूप में रखने से कुछ भी मदद नहीं मिलेगी, क्योंकि बयान के लिए एक अर्धविराम अभी भी समाप्त होने की आवश्यकता है।

जैसा कि @ETHproductions द्वारा सुझाया गया है, बस x+=xकाम करता है:

class A{public static void main(String[]a){String x="1";for(;;)x+=x;}}

जिसका फायदा @ ऑलिवियर ग्रेजायर के टिप से भी मिल सकता है:

class A{public static void main(String[]a){for(String x="1";;)x+=x;}}

मेरे बारे में केवल यह गलतफहमी है कि यह ढेर पर डेटा आवंटित करने की गारंटी नहीं है , क्योंकि एक कुशल जेवीएम आसानी से महसूस कर सकता है कि xकभी भी स्थानीय फ़ंक्शन से बच नहीं जाता है। का प्रयोग intern()से बचा जाता है यह चिंता का विषय है क्योंकि प्रशिक्षु तार अंत में खत्म एक स्थिर क्षेत्र में जमा हो जाती। हालाँकि, हॉटस्पॉट OutOfMemoryErrorउस कोड के लिए उत्पन्न करता है , इसलिए मुझे लगता है कि यह ठीक है।

अपडेट: @ ऑलिवर ग्रीगोइरे ने यह भी बताया कि बहुत सी मेमोरी उपलब्ध होने के बजाय x+=xकोड चल सकता है। ऐसा इसलिए है क्योंकि जावा 32-बिट प्रकार को अनुक्रमणिका सरणियों का उपयोग करता है (और स्ट्रिंग्स केवल सरणियाँ हैं )। यह समाधान को प्रभावित नहीं करता है क्योंकि बाद के लिए आवश्यक मेमोरी स्ट्रिंग की लंबाई में द्विघात है, और इस प्रकार 2 ^ 62 आवंटित बाइट्स के क्रम पर स्केल होना चाहिए।StringIndexOutOfBoundsExceptionOOMintcharx+=x.intern()

— DepressedDaniel
स्रोत
PPCG में आपका स्वागत है! मैं जावा को बहुत अच्छी तरह से नहीं जानता; अगर आपने अभी किया तो क्या होगा x+=x;?
— ETHproductions 4
आप x+=x.intern()लूप के लिए अंतिम अर्धविराम के पीछे रखकर अर्धविराम लगा सकते हैं
— MasterX244
अच्छा जवाब। मुझे पता था कि स्ट्रिंग internइंग के साथ कुछ होना था लेकिन मैं असुरक्षित के साथ बहुत खुश था और अंतिम रूप दे रहा था कि मैं देख रहा था, हाहा। मूल रूप से यह प्रश्न "मेमोरी लीक" को निर्दिष्ट करता है, यही वजह है कि मैंने सिर्फ एक स्ट्रिंग कॉनैट जवाब नहीं दिया।
— प्रहार
यदि आपका उत्तर जावा के एक विशिष्ट कार्यान्वयन पर निर्भर करता है, और जरूरी नहीं कि सभी जावा कार्यान्वयन के लिए पोर्टेबल हो, तो आप जानकारी को शीर्षक (जैसे # Java (HotSpot), 71 bytes) में रख सकते हैं । इस तरह, आपको समाधान के बारे में चिंता करने की आवश्यकता नहीं है; कार्यान्वयन-विशिष्ट कार्यक्रम न केवल गोल्फिंग में, बल्कि प्रोग्रामिंग की व्यापक दुनिया में भी आम हैं, और जब तक आप जो कर रहे हैं उसके बारे में जानते हैं, कभी-कभी एक पोर्टेबल कार्यक्रम की तुलना में अधिक उपयुक्त हो सकते हैं, कहते हैं, एक- स्क्रिप्ट बंद।
1
हम्म ... x+=x;पूरी याददाश्त नहीं थकती । 64 जीबी के साथ, मुझे StringIndexOutOfBoundsExceptionओओएम नहीं बल्कि एक मिलता है । के साथ .intern()मैं अभी भी OOM मिलता है।
— ओलिवियर ग्रेजायर 18
8

पर्ल 6 , 13 बाइट्स

@= eager 0..*

स्पष्टीकरण:

@ = परिणाम को किसी अनाम सरणी में संग्रहीत करें

eager निम्नलिखित सूची को उत्सुक बनाएं

0 .. * अनंत सीमा शून्य से शुरू होती है

— ब्रैड गिल्बर्ट b2gills
स्रोत
8

///, 7 बाइट्स

/a/aa/a

लगातार विज्ञापन nauseum के aसाथ बदलें aa।

— steenbergh
स्रोत
12
*aad naauseum
— तैमोथीम
1
* ad nauseam=>aad naauseaam
— आरोन 12
किस बारे में //a/? ऐसा लगता है कि हमेशा के लिए `` (कुछ भी नहीं) द्वारा प्रतिस्थापित किया जाता है a, लेकिन यह निश्चित रूप से निर्दिष्ट नहीं है।
— सेड्रिक रीचेनबैक
6

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

i=9
while 1:i*=i

यह इस तथ्य से आता है कि पायथन 3 में पूर्णांक आकार की कोई सीमा नहीं है; इसके बजाय, पूर्णांक उतनी मेमोरी ले सकते हैं जितना सिस्टम संभाल सकता है (यदि मेरी समझ के बारे में कुछ गलत है, तो मुझे सही करें)।

— artificialnull
स्रोत
शीर्षक का तात्पर्य है कि स्मृति को लीक किया जाना चाहिए। लेकिन यह वास्तव में मेमोरी को लीक नहीं करता है। लेखक को शायद स्पष्ट करना चाहिए।
— गेहूं जादूगर
6

जंग, 46 बाइट्स

fn main(){loop{std::mem::forget(Box::new(1))}}

स्मृति से बाहर होने तक ढेर आवंटन को लीक करते हुए, इस जंग कार्यक्रम के बारे में कुछ दिलचस्प नोटिस करें?

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

— हैराल्ड कोर्नेलियुसेन
स्रोत
6

TI-83 हेक्स असेंबली, 7 बाइट्स

PROGRAM:M
:AsmPrgm
:EF6A4E
:C3959D
:C9

ERR:MEMORYओएस द्वारा फेंक दिए जाने तक अनिश्चित काल तक एपवार्स बनाता है। साथ चलाना Asm(prgmM)। मैं हेक्स अंकों की प्रत्येक जोड़ी को एक बाइट के रूप में गिनता हूं।

— सताना
स्रोत
6

पायथन, 8 बाइट्स

2**9**99

ओपी ने एक प्रोग्राम की तकनीकीता की अनुमति दी है जो तकनीकी रूप से "हमेशा के लिए" नहीं चलता है, लेकिन किसी भी कंप्यूटर की तुलना में अधिक मेमोरी आवंटित करता है जो संभवतः संभाल सकता है। यह काफी गूगोलोप्लेक्स नहीं है (जो कि 10**10**10011 बाइट्स होगा), लेकिन भोलेपन से, संख्या का आधार 2 लॉग करें

>>> 9**99.
2.9512665430652752e+94

इसका प्रतिनिधित्व करने के लिए 10, 94 बिट्स। वोल्फ्रामअल्फा कहते हैं कि 10 ^ 76 गहरी वेब की तुलना में बड़ा है (ध्यान रखें कि ब्रह्मांड में लगभग 10 ^ 80 परमाणु हैं )।

9 के बजाय 2 आप क्यों पूछते हैं? यह बहुत अंतर नहीं करता है (9 का उपयोग केवल बिट्स की संख्या को एक कारक से बढ़ाएगा log2(9) = 3.2, जो प्रतिपादक को भी नहीं बदलता है)। लेकिन दूसरी ओर, कार्यक्रम 2 के साथ बहुत तेजी से चलता है, क्योंकि गणना सरल है। इसका मतलब यह है कि यह स्मृति को तुरंत भर देता है, 9 संस्करण के विपरीत, जो आवश्यक गणनाओं के कारण थोड़ा अधिक समय लेता है। आवश्यक नहीं है, लेकिन अच्छा है यदि आप इसे "परीक्षण" करना चाहते हैं (जो मैंने किया था)।

— asmeurer
स्रोत
5

जेली , 3 2 बाइट्स

डेनिस ( Wरैप्स) के लिए -1 बाइट

Wß

एक लिंक (यानी फ़ंक्शन या विधि), जो एक पूर्ण कार्यक्रम के रूप में भी काम करता है, जो पुन: अपने इनपुट को एक सूची में लपेटता है।

इनपुट शून्य के रूप में शुरू होता है इसलिए पहला पास सूची बनाता है [0]
दूसरा पास तब यह [[0]]
तीसरा पास बनाता है [[[0]]]
और फिर इसे बनाता है ...

पिछला 3 बटर, जो बहुत तेज़ी से लीक होता है:

;Ẇß

इसके इनपुट के सभी गैर-रिक्त सन्निहित उपविदों को इसके इनपुट के लिए पुनरावर्ती बनाता है।
[0]-> [0,[0]]-> [0,[0],[0],[[0]],[0,[0]]]और इतने पर ...

— जोनाथन एलन
स्रोत
अगर मैं नियमों को सही ढंग से समझूं, ‘ßतो बहुत कुछ होना चाहिए।
— डेनिस
क्या यह वास्तव में "लगातार स्मृति आवंटित करता है" (छोटे चींटियों के लिए निरंतर आवंटन रखते हुए पायथन के बारे में सोच)।
— जोनाथन एलन
1
काफी उचित। Wßहालांकि अभी भी बिल फिट होना चाहिए।
— डेनिस
5

जावा 7, 106 बाइट्स

class A{public void finalize(){for(;;)Thread.yield();}public static void main(String[]a){for(;;)new A();}}

कम गोल्फ वाला

class A{
    @Override
    public void finalize(){
        for(;;) {
            Thread.yield();
        }
    }
    public static void main(String[]a){
        for(;;){
            new A();
        }
    }
}

finalizeविधि कचरा कलेक्टर द्वारा एक वस्तु पर कहा जाता है जब कचरा संग्रहण निर्धारित करता है वस्तु के लिए कोई अधिक संदर्भ देखते हैं कि है। मैंने बस इस विधि को हमेशा के लिए पाश में बदल दिया है ताकि कचरा कलेक्टर वास्तव में स्मृति को मुक्त न करे। में mainपाश मैं नई वस्तुओं है जो कभी नहीं साफ किया जाएगा, ताकि अंत में इस सभी उपलब्ध स्मृति का उपयोग करेगा पैदा करते हैं।

जावा 7 (मजेदार विकल्प), 216 बाइट्स

import sun.misc.*;class A{public static void main(String[]a)throws Exception{java.lang.reflect.Field f=Unsafe.class.getDeclaredField("theUnsafe");f.setAccessible(1>0);for(;;)((Unsafe)f.get(null)).allocateMemory(9);}}

कम गोल्फ वाला

import sun.misc.*;
class A{
    public static void main(String[]a)throws Exception{
        java.lang.reflect.Field f=Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe u = (Unsafe)f.get(null);
        for(;;) {
            u.allocateMemory(9);
        }
    }
}

यह एक मजेदार है जो किसी भी चीज़ से अधिक है। यह उत्तर Unsafeसूर्य पुस्तकालय का उपयोग करता है जो एक अनिर्दिष्ट आंतरिक एपीआई है। प्रतिबंधित एपीआई की अनुमति देने के लिए आपको अपनी संकलक सेटिंग्स को बदलने की आवश्यकता हो सकती है। Unsafe.allocateMemoryबाइट्स की एक निर्दिष्ट राशि आवंटित करता है (बिना किसी सीमा जाँच के) जो कि ढेर पर नहीं है और जावा के कचरा संग्राहक प्रबंधन के तहत नहीं है, इसलिए यह मेमोरी तब तक इधर-उधर रहेगी जब तक आप कॉल Unsafe.freeMemoryनहीं करते या जब तक कि jvm मेमोरी से बाहर नहीं निकल जाती।

— प्रहार
स्रोत
1
सोच रहा था कि क्या मैं यहां जावा देखूंगा।
— मैजिक ऑक्टोपस Urn
यदि कचरा संग्रहकर्ता एक अलग थ्रेड में चल रहा है तो केवल पहला काम नहीं करता है?
— tbodt
@tbodt हाँ, लेकिन मेरा मानना ​​है कि ऐसा कभी नहीं होता। कचरा संग्रह एक डोरेमोन थ्रेड में होता है जिसे कचरा कलेक्टर कहा जाता है
— पोक
@Poke की क्या गारंटी है? यदि उत्तर अभी भी ठीक नहीं है, लेकिन आपको यह स्पष्ट करना चाहिए कि यह केवल तभी काम करता है जब कचरा कलेक्टर अपने स्वयं के धागे में चलता हो
— tbodt
@tbodt मुझे लगता है लेकिन मैं निश्चित रूप से, ईमानदारी से नहीं हूँ।
— पोक
5

हास्केल, 24 बाइट्स

f x=f$x*x
main=pure$!f 9

हास्केल में मुख्य समस्या आलस्य को हरा देना है। mainकुछ IOप्रकार की आवश्यकता होती है , इसलिए केवल कॉल main=f 9करने से काम नहीं चलेगा। का उपयोग करते हुए main=pure(f 9)लिफ्टों के प्रकार के f 9एक करने के लिए IOलिखें। हालाँकि निर्माण का उपयोग main=pure 9करना कुछ भी नहीं करता है,9 वापस लौटाया जाता है या कहीं भी प्रदर्शित नहीं किया जाता है, लेकिन इसे छोड़ दिया जाता है, इसलिए इसके तर्क का मूल्यांकन करने की कोई आवश्यकता नहीं है pure, इसलिए main=pure(f 9)किसी भी स्मृति को आवंटित fनहीं किया जाता है जैसा कि नहीं कहा जाता है। मूल्यांकन लागू करने के लिए, $!ऑपरेटर मौजूद है। यह केवल एक फ़ंक्शन को एक तर्क पर लागू करता है लेकिन पहले तर्क का मूल्यांकन करता है। इसलिए main=pure$!f 9मूल्यांकन का उपयोग करना fऔर इसलिए लगातार अधिक मेमोरी आवंटित करना।

— Laikoni
स्रोत
जब संकलित किया जाता है, तो रनटाइम लूप का पता लगाता है और निष्पादन को तोड़ता है
— Angs
@ आंग्स मैंने विंडोज़ पर ghc से संकलित किया है और यह खुशी से मेमोरी आवंटित करता रहता है ... मैंने इसे 3GB पर रोक दिया।
— लैकोनी
का उपयोग करते हुए f x=f xकाम करता है भी, है ना? (32 बाइट्स)
— wchargin
@wchargin मुझे ऐसा नहीं लगता, f x=f xएक अनंत लूप पैदा करता है, लेकिन नई मेमोरी को आवंटित किए बिना।
— लकोनी 17
अच्छा है, जिससे बिग्नम गणना द्वारा मेमोरी ब्लो-आउट हो गई! f!x=x*f(x*x)इसे अनुकूलन-प्रमाण बनाना चाहिए।
— विल नेस
5

डीसी, 7 बाइट्स

[ddx]dx

[ddx]स्टैक में "ddx" युक्त स्ट्रिंग को धकेलता है। dxइसे डुप्लिकेट करता है फिर इसे कोड के रूप में निष्पादित करता है (स्टैक पर एक प्रति छोड़कर)। जब निष्पादित किया जाता है, तो यह दो डुप्लिकेट बनाता है फिर एक को निष्पादित करता है, हर बार स्टैक पर एक और कॉपी छोड़ता है।

— faubi
स्रोत
रुको, तो अगर यह समानांतर में चल सकता है, तो यह मेमोरी को तेजी से आवंटित करेगा?
— हाइपरन्यूट्रिनो
5

हास्केल (ghc 8.0.1 का उपयोग करके), 11 बाइट्स

m@main=m>>m

गैर-पूंछ पुनरावृत्ति। mainखुद को और फिर खुद को फिर से बुलाता है।

— nimi
स्रोत
क्या यह ढेर या स्टैक पर आवंटित होता है? (मैं या तो विश्वास कर सकते हैं, यह अच्छी तरह से उपयोग में हास्केल संकलक पर निर्भर कर सकता है।)
1
@ ais523: यह निर्भर करता है। हास्केल का कोई कॉल स्टैक नहीं है । रन टाइम सिस्टम आरटीएस में पैटर्न मिलान के लिए एक मेमोरी क्षेत्र है जिसे "स्टैक" भी कहा जाता है। यह ढेर ढेर पर आवंटित किया गया है। ईमानदारी से, मुझे नहीं पता कि यहां क्या चल रहा है, क्योंकि Stack space overflow: current size 33624 bytes.33k के साथ कार्यक्रम विफल रहता है , कुल मेमोरी के 6 जी के विपरीत काफी कम लगता है जो ओएस रिपोर्टिंग कर रहा है।
— नीमी
1
@ ais523: ghc त्रुटि संदेश की स्मृति जानकारी में एक बग प्रतीत होता है , इसलिए यह बताना कठिन है कि वास्तव में क्या होता है।
— निमि।
उबंटू पर जीएचसी 7.10.3 पर संकलित, ऐसा लगता है कि अनुकूलन अक्षम होने पर भी मेमोरी की निरंतर मात्रा लगती है
— Angs
@ भाषा: हम्म, मैं मैकओएस पर 8.0.1 ghc का उपयोग करता हूं। मैं इसे संपादित करूंगा।
— nimi
5

सी (लिनक्स), 23 बाइट्स

main(){while(sbrk(9));}

sbrk()दिए गए बाइट्स द्वारा डेटा खंड के शीर्ष को बढ़ाता है, इस प्रकार कार्यक्रम को आवंटित स्मृति की मात्रा को प्रभावी ढंग से बढ़ाता है - कम से कम जैसा VIRTकि topआउटपुट के क्षेत्र में बताया गया है । यह केवल लिनक्स पर काम करता है - macOS कार्यान्वयन स्पष्ट रूप से एक अनुकरण है जो केवल 4MB तक के आवंटन की अनुमति देता है।

तो थोड़ा और सामान्य जवाब:

सी, 25 बाइट्स

main(){while(malloc(9));}

मैंने इसे macOS एक्टिविटी मॉनिटर पर देखा। यह लगभग 48GB तक चला गया, फिर अंततः इस प्रक्रिया को एक SIGKILL सिग्नल प्राप्त हुआ। FWIW मेरी मैकबुक प्रो में 16GB है। उपयोग की गई अधिकांश मेमोरी को संपीड़ित बताया गया था।

ध्यान दें कि प्रश्न को प्रभावी रूप से प्रत्येक आबंटन के लिए लिखा जाना आवश्यक है, जो यहाँ स्पष्ट रूप से नहीं होता है। हालांकि यह ध्यान रखना महत्वपूर्ण है कि प्रत्येक malloc(9)कॉल के लिए, यह केवल 9 उपयोगकर्ता द्वारा अनुरोधित बाइट्स नहीं हैं जो आवंटित किए गए हैं। आवंटित किए गए प्रत्येक ब्लॉक के लिए एक मॉलोक हेडर होगा जो कि ढेर पर कहीं से भी आवंटित किया गया है, जो आवश्यक रूप से malloc()इंटर्नल द्वारा लिखा गया है ।

— डिजिटल आघात
स्रोत
Malloc के साथ, आप सीधे मेमोरी में नहीं लिख रहे हैं क्योंकि Malloc कुछ भी इनिशियलाइज़ नहीं करता है। मैमोरी केवल इसलिए आवंटित की जाती है क्योंकि मैलोक को मेमोरी प्रबंधन के लिए कुछ आंतरिक भंडारण की आवश्यकता होती है। तो जवाब वास्तव में मानक नहीं है, लेकिन मुझे लगता है कि यह वैसे भी हर जगह काम करता है।
— अंज़ी डेस
@ हांजी हां। हालाँकि, मुझे लगता है कि यह अभी भी काम करता है, क्योंकि भले ही उपयोगकर्ता मेमोरी वास्तव में आवंटित नहीं की जाती है क्योंकि यह लिखा गया है, प्रत्येक malloc()एड ब्लॉक में अभी भी अपना वास्तविक आवंटित स्थान होना चाहिए। यह macOS और Ubuntu पर काम करता है।
— डिजिटल ट्रामा
लिखे जा रहे प्रत्येक पृष्ठ के प्रश्न में स्थिति बल्कि अर्थहीन है; यहां तक ​​कि अगर आप यह मान लेना चाहते हैं कि ओएस उचित प्रतिबद्ध लेखांकन नहीं करता है, तो कार्यान्वयन विवरणों की परवाह किए बिना, आवंटन के लिए आवश्यक बहीखाता पद्धति की गैर-आवश्यक राशि है। चाहे वह आवंटन के समीप हो (पेजों को छुआ जा सकता है) या नहीं, यह अंततः गैरजरूरी डेटा के साथ बहीखाता पद्धति के लिए मनमाने ढंग से स्मृति की खपत करेगा।
— आर ..
आप इसे एक बाइट के रूप में छोटा कर सकते हैं main(){main(malloc(9));}, लेकिन अतिप्रवाह को ढेर नहीं करने के लिए, इसे टेल कॉल ऑप्टिमाइज़ेशन की आवश्यकता होती है, और जीसीसी ऐसा नहीं करना चाहता है main...
— R ..
यदि आप मालॉक (9) को कॉलोक (9,9) से बदलते हैं, तो 9-बाइट ब्लॉक के 9 उदाहरणों के लिए पर्याप्त मेमोरी आवंटित की जाएगी (इसलिए 81 और 144 बाइट्स के बीच, संरेखण पर निर्भर करता है। हालांकि, और अधिक महत्वपूर्ण बात, कॉलॉक। ) मेमोरी के ब्लॉक को शून्य से भर देगा, अंतर्निहित ओएस को इसके लिए भंडारण आवंटित करने के लिए मजबूर करता है।
— CSM
5

पर्ल, 4 बाइट्स

do$0

मौजूदा दुभाषिया में खुद को निष्पादित करता है। समाप्त होने पर, निष्पादन कॉलिंग स्क्रिप्ट पर लौटता है, जिसके लिए कॉल स्टैक की आवश्यकता होती है।

— Primo
स्रोत
अच्छा और छोटा, हालांकि यह स्मृति को जल्दी से बेकार नहीं करता है।
— बेनगोल्डबर्ग
4

रैकेट, 13 बाइट्स

(let l()(l)1)

यदि मेरा उत्तर इस प्रश्न के अंतर्गत आता है तो मैं पूरी तरह निश्चित नहीं हूँ। कृपया मुझे बताएं कि क्या मुझे यह उत्तर निकालना चाहिए।

— winny
स्रोत
क्या आप बता सकते हैं कि यह कैसे काम करता है?
— tbodt
1
ओह, तो यह परिभाषित कर रहा है l एक फ़ंक्शन के रूप में जो गैर-टेलकॉल पुनरावृत्ति करता है। मैं कहता हूँ कि यह मायने रखता है।
— tbodt
@tbodt हाँ आप पैसे पर सही हैं
— विनी
4

जावास्क्रिप्ट 22 21 17 16 15 बाइट्स

for(a=0;;)a=[a]

@Jonathan Allan's Jelly जवाब के रूप में एक अन्य सूची में सूची को लपेटकर 4 बाइट्स सहेजे गए।

@ बाइट्स के लिए 1 बाइट का धन्यवाद सहेजा गया

वैकल्पिक समाधान 15 बाइट्स (केवल उचित पूंछ कॉल के साथ काम करता है)

f=a=>f([a]);f()
— Lmis
स्रोत
1
ES6 के साथ अपने दूसरे उदाहरण पर, क्या आप ऐसा नहीं कर सकते f=_=>f();f()? 12 बाइट्स
— काट लिया
@ लिखा हुआ मुझे यकीन नहीं है। यदि यह कॉल स्टैक को उड़ाने के लिए गिना जाता है, तो उचित पूंछ कॉल के बिना जाने का रास्ता होगा। TCO के साथ, मुझे नहीं लगता कि कोई मेमोरी लीक होगी, क्या वहाँ होगी?
— लमिस
दोनों ने मेरे लिए कॉल स्टैक उड़ा दिया । मैं वास्तव में पूंछ कॉल से परिचित नहीं हूं इसलिए मैं उस पर टिप्पणी नहीं कर सकता।
— काटे गए
1
मैं देख रहा हूँ, मुझे यकीन नहीं था कि तुम्हारी स्मृति कैसे लीक हो रही थी
— काट लिया
1
आप निकाल सकते हैं a=0। पहले पुनरावृत्ति में परिणाम होगाa=[undefined]
— फ्लोरेंट
4

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

loop{$*<<9}

धक्का रहता है 9पर$* है, जो शुरू में रूबी की प्रक्रिया के लिए आदेश पंक्ति तर्क पकड़े एक सरणी है।

— daniero
स्रोत
4

05AB1E , 2 बाइट्स

[A

इसे ऑनलाइन आज़माएं! बस धक्के लगाता रहेगाabcdefghijklmnopqrstuvwyxz अनंत काल के लिए स्टैक पर रहेंगे।

सभी संभव 2-बाइट समाधान:

[  # Infinite loop.
 A # Push alphabet.
 0 # Push 0.
 1 # Push 1.
 2 # Push 2.
 3 # Push 3.
 4 # Push 4.
 5 # Push 5.
 6 # Push 6.
 7 # Push 7.
 8 # Push 8.
 9 # Push 9.
 T # Push 10.
 X # Push 1.
 Y # Push 2.
 ® # Push -1.
 ¶ # Push \n.
 º # Push len(stack) > 0, so 0 once then 1 for eternity.
 ð # Push a space.
 õ # Push an empty string.
 ¾ # Push 0.
 ¯ # Push [].
 M # Push -inf.
 ) # Wrap current stack in an array.
— जादू ऑक्टोपस Urn
स्रोत
बहुत गहन! अच्छा लगा।
— टिमोथीम
3

पायथन, 35 बाइट्स

def f(a=[]):a.append(a)
while 1:f()

a कभी रिलीज नहीं होती है और जब तक आप हिट नहीं करते तब तक बस बड़ा होता है MemoryError

आप पायथन ट्यूटर पर निष्पादन देख सकते हैं ।

— Noelkd
स्रोत
1
क्या आप कर सकते हैं a+=a,?
— साइओस
किसी फ़ंक्शन की आवश्यकता नहीं है, यहां मेरा गोल्फ है
— FlipTack
@ Flp.Tkc इस प्रश्न को बदलने के बाद मैंने यह उत्तर लिखा था कि मैंने वही किया होगा जो आपने किया था (+ - कुछ अक्षर) यदि यह अपने वर्तमान प्रारूप में था।
— नोएलकेड
3

TI-BASIC, 8

:Lbl A
:While 1
:Goto A

(सभी 1-बाइट टोकन, और दो नए समाचार)

यह लगातार मेमोरी को लीक करता है क्योंकि संरचित नियंत्रण प्रवाह जैसे कि Whileप्रत्याशित द्वारा बंद किया जा रहा है Endऔर स्टैक पर कुछ धक्का देता है (ओएस स्टैक नहीं, हीप मेमोरी में एक अलग स्टैक) उस पर नज़र रखने के लिए। लेकिन यहाँ हम Gotoलूप को छोड़ने के लिए उपयोग कर रहे हैं (इसलिए Endस्टैक से चीज़ को हटाने के लिए निष्पादित नहीं किया जाता है), Whileफिर से देखा जाता है, चीज़ को फिर से धक्का दिया जाता है, आदि। इसलिए यह बस उन्हें धक्का देता है जब तक आप नहीं मिलतेERR:MEMORY

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