सबसे छोटा ऑटो-विनाशकारी लूप


61

आपका काम एक पूरा कार्यक्रम या समारोह है कि कोई इनपुट लेता है और लूप (किसी भी प्रकार चलाता है लिखना है while, for, foreach, do, do-while, do-loop, goto, प्रत्यावर्तन, आदि) कि एक त्रुटि, जिसका मतलब है कि कार्यक्रम चलाने में ही रोकने के लिए और करना होगा जिससे में खत्म हो जाएगा बाहर जाएं।

नियम:

  1. त्रुटि एक रन-टाइम त्रुटि, अखंडित अपवाद या कुछ भी होना चाहिए जो प्रोग्राम को स्वयं समाप्त करता है।
  2. त्रुटि को exit;किसी बिंदु पर स्पष्ट रूप से (या समतुल्य) बुलाए बिना कार्यक्रम से रोकना और बाहर निकलना होगा।
  3. जैसे संदेश Warning:, Notice:, आदि, कि इस कार्यक्रम का कारण नहीं है अपने आप समाप्त करने के लिए मान्य नहीं हैं। उदाहरण के लिए शून्य से PHP डिवीजनों में एक Warningसंदेश का उत्पादन होता है, लेकिन कार्यक्रम बंद नहीं होगा और अभी भी चलेगा, यह एक वैध जवाब नहीं है।
  4. लूप को कम से कम एक पूर्ण चक्र चलना चाहिए। दूसरे शब्दों में त्रुटि दूसरे चक्र और आगे शुरू हो सकती है। यह गलत कोड सिंटैक्स का उपयोग करके त्रुटि का कारण बनने से बचने के लिए है: कोड को सिंटैक्टिक रूप से सही होना चाहिए।
  5. for(;;);यदि यह उपरोक्त नियमों का सम्मान करता है, तो लूप भी अनंत (उदाहरण ) हो सकता है, लेकिन रन-टाइम त्रुटि में खुद को समाप्त करने के लिए 2 मिनट से अधिक का समय नहीं लेना चाहिए।
  6. टेल कॉल ऑप्टिमाइज़ेशन के बिना पुनरावर्तन अमान्य है ( 1 , 2 )।
  7. यह इसलिए सबसे छोटा कोड जीतता है।
  8. मानक खामियों को मना किया जाता है।

C # उदाहरण ( ऑनलाइन परीक्षा ):

using System;
public class Program {
    public static void Main() {
        int i;
        int[] n;
        n = new int[5];
        for(i=0; i<7; i++) {
            n[i] = i;
            Console.WriteLine(n[i]);
        }
    }
}


Output: 

0
1
2
3
4
Run-time exception (line 9): Index was outside the bounds of the array.

Stack Trace:

[System.IndexOutOfRangeException: Index was outside the bounds of the array.]
  at Program.Main(): line 9

लीडरबोर्ड:

var QUESTION_ID=104323,OVERRIDE_USER=59718;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="<h1>"+e.body.replace(OVERRIDE_REG,"")+"</h1>")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/<a/.test(o)&&(o=jQuery(o).text()),s[o]=s[o]||{lang:e.language,user:e.user,size:e.size,link:e.link}});var t=[];for(var o in s)s.hasOwnProperty(o)&&t.push(s[o]);t.sort(function(e,s){return e.lang>s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important;font-family:Arial,Helvetica; font-size:12px}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr></thead> <tbody id="answers"> </tbody> </table> </div><div id="language-list"> <h2>Winners by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr></thead> <tbody id="languages"> </tbody> </table> </div><table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr></tbody> </table>

लीडरबोर्ड स्निपेट के लिए मार्टिन एंडर को धन्यवाद


बस स्पष्ट होने के लिए, TCO के बिना पुनरावृत्ति का उपयोग तब तक किया जा सकता है जब तक कि त्रुटि को बहुत अधिक पुनरावर्तन के साथ नहीं करना है, सही? (उदाहरण के लिए, एक पुनरावर्ती कार्य जो दूसरी पुनरावृत्ति पर त्रुटियां करता है)
ETHproductions

@ETHproductions यह चैट में डेनिस द्वारा सुझाया गया था: "यह तय करना मुश्किल हो सकता है कि क्या इस मामले में एक पूर्ण चक्र [पुनरावृत्ति] में पूरा हो गया है। पूंछ पुनरावृत्ति थोरा बिल फिट बैठता है, लेकिन निष्पादन समाप्त होने पर केवल TCO एक चक्र पूरा करता है। एक त्रुटि के द्वारा। [...] मैं कहूंगा कि TCO के बिना पुनरावृत्ति अमान्य है। "
मारियो

में for(a;b;c)d;, विच कथन के बाद पहला चक्र समाप्त होता है? क्या cबयान के पहले साक्ष्य को तोड़ना वैध है ?
हेडी

1
@ हेदी यहां मेरी विनम्र राय है (ओपी नहीं): सभी प्रविष्टियों को एक पूर्ण चक्र पूरा करना होगा, जिसका अर्थ है कि उन्हें एक दूसरे चक्र में प्रवेश करना होगा ; इसका मतलब है कि कम से कम एक बयान दूसरी बार चलाया जाता है । चूंकि आपके उदाहरण में निष्पादन का क्रम है a, b, d, c, b, d, c, ..., bचक्र की शुरुआत है, और कम से कम दूसरी बार चलना चाहिए।
ETHproductions

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

जवाबों:


33

MATL , 5 1 बाइट

@ मार्टिनएंडर के सीजेएम उत्तर से लिया गया विचार

`

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

`    % Do...while loop
     % Implicit end. The loop continues if the top of the stack is true.
     % After the first iteration, since the stack is empty, the program 
     % implicitly tries to take some non-existing input, and finishes
     % with an error

पुराना संस्करण

2:t"x

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

2:   % Push [1 2]
t    % Duplicate
"    % For each (i.e. do the following twice)
  x  %   Delete top of the stack. Works the first time. The second it tries to
     %   implicitly take some non-existing input, and finishes with an error

3
ऑफ़लाइन भी काम करता है। कोई इनपुट का मतलब यह नहीं है कि आप खाली इनपुट ग्रहण कर सकते हैं।
डेनिस

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

यह निश्चित रूप से निश्चित नहीं है कि MATL आंतरिक रूप से कैसे काम करता है, लेकिन यदि आप इसे इनपुट (जैसे कि TIO के बैकेंड) के अनुरोध के अक्षम वातावरण में निष्पादित करते हैं, तो यह किसी भी इनपुट को प्राप्त करने में सक्षम नहीं होगा। इसके अलावा, Ctrl-D या OS पर निर्भर समकक्ष को खाली इनपुट भेजने की अनुमति दी जानी चाहिए।
डेनिस

35

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

गैर-दिलचस्प 0 विभाजन दृष्टिकोण:

for x in 1,0:x/x

पहला पुनरावृत्ति गणना करता है 1 / 1, जो ठीक काम करता है। दूसरा पुनरावृत्ति गणना करने की कोशिश करता है 0 / 0, जिसके परिणामस्वरूप ZeroDivisionErrorफेंक दिया जाता है।

17 बाइट्स (व्यक्तिगत पसंदीदा)

i=1
while i:del i

प्रारंभ में, i=1जो सत्य है, इसलिए लूप में प्रवेश किया जाता है।

पहली बार लूप चलाया जाता है, चर iहटा दिया जाता है।

इसका मतलब यह है कि, दूसरी बार, iअब एक चर नहीं है और इसलिए इसका मूल्यांकन विफल रहता हैNameError: name 'i' is not defined.


एक और 15 बाइट समाधान def _():_()(न्यूलाइन) होगा _(), क्योंकि पायथन पूंछ पुनरावृत्ति का अनुकूलन नहीं करता है। हालाँकि, यह नियम # 6 का उल्लंघन करता है।


अगर आप की जगह 17 बाइट्स समाधान भी काम करता है while iके साथ while 1है क्योंकि यह नष्ट करने के लिए कोशिश करता है iफिर से;
user6245072

2
@ user6245072 हाँ, दोनों स्निपेट को बहुत सारे कामकाजी समाधानों के लिए तुच्छ रूप से संशोधित किया जा सकता है
FlipTack

आप अपनी delचाल का उपयोग कुछ और से दाढ़ी बनाने के लिए कर सकते हैं while 1:del id:।
डीएसएम


18

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

Ṿß

स्मृति से भाग कर ही मारता है। स्थानीय रूप से ~ 100 सेकंड के बाद ऐसा करता है।

इसे ऑनलाइन आज़माएं! ( डेब्यू दराज में मृत्यु प्रमाण पत्र )

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

Ṿß  Main link. Argument: x. Implicit first argument: 0

Ṿ   Uneval; yield a string representation of x.
 ß  Recursively call the main link.
    Jelly uses TCO, so the first cycle finishes successfully before entering
    the next one.

पहले कुछ पुनरावृत्तियों उपज:

'0'
'”0'
'””,”0'
'””,””,”,,””,”0'
'””,””,”,,””,””,”,,””,”,,”,,””,””,”,,””,”0'
'””,””,”,,””,””,”,,””,”,,”,,””,””,”,,””,””,”,,””,”,,”,,””,””,”,,””,”,,”,,””,”,,”,,””,””,”,,””,””,”,,””,”,,”,,””,””,”,,””,”0'

उसके बाद, यह असली बदसूरत, असली तेज हो जाता है।


जेली की मेमोरी सीमा क्या है?
tuskiomi

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

28
इसलिए हर 2 साल में, हम
tuskiomi

तो बहुत सी RAM के साथ धीमी मशीन पर स्थिति # 5 विफल हो जाएगी?
मैड फिजिसिस्ट

@MadPhysicist यह सही है। हालांकि यह समय सीमा के साथ एक अंतर्निहित समस्या है। अनुपालन बहुत निर्भर करता है कि किस मशीन पर कार्यक्रम चलाया जाता है।
डेनिस

13

वी , 2 बाइट्स

òl

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

वी के लिए यह सही चुनौती है क्योंकि मैं पहले से ही हर समय ऐसा करता हूं! वास्तव में, V के पास कोई शर्त भी नहीं है, इसमें केवल ऐसे कार्य हैं जो एक त्रुटि पर टूटते हैं। इस मामले में, òसाधन "हमेशा के लिए दोहराएं" और lइसका मतलब है "सही कदम"।

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


3
रुको, l"सही कदम" का मतलब है? " lएफ्ट नहीं"?
कॉनर ओ'ब्रायन

1
@ कोनोरो ब्रायन येप। इसके लिए वास्तव में कुछ अच्छे ऐतिहासिक कारण हैं
DJMcMayhem

3
चुनौती को दूसरे पुनरावृत्ति पर दुर्घटना के उत्तर की आवश्यकता होती है या बाद में, पहली यात्रा पर नहीं।
मार्टिन एंडर

11

जावास्क्रिप्ट (ईएस 6), 13 बाइट्स

f=_=>f(_?a:1)

यह एक पुनरावर्ती कार्य है जो एक बार ठीक चलता है, फिर फेंकता है ReferenceError: a is not definedऔर बुझता है।

यहाँ एक 15-बाइट गैर- ES6 संस्करण है:

for(i=0;;)i=i.a

यह एक बार ठीक चलता है, फिर फेंकता है TypeError: i is undefinedऔर बुझता है।


10

बैश 4.2, 22 बाइट्स

exec $0 $@ $[2**$#%-1]

टीआईओ में काम नहीं करता क्योंकि इसमें बैश 4.3 है, और मैं जिस बग पर भरोसा कर रहा हूं वह आखिरकार तय हो गया।

सत्यापन

$ xxd -c 22 -g 22 self-destruct
0000000: 6578656320243020244020245b322a2a2423252d315d  exec $0 $@ $[2**$#%-1]
$ ./self-destruct
Floating point exception

एक बार प्रोग्राम 2 63 मॉड -1 की गणना करने की कोशिश करने पर यह क्रैश हो जाता है , जो बैश 4.2 और पुराने संस्करणों में एक ज्ञात बग के कारण क्रैश हो जाता है।


10

PHP, 22 21 20 18 बाइट्स

यह PHP पर निर्भर करता है कि वह किसी वैरिएबल को फंक्शन का नाम दे और उसे चलाने की कोशिश करे।

यह केवल piफ़ंक्शन का नाम दो बार संक्षिप्त करता है । यह PHP को a के साथ मारता है Fatal Error: Uncaught Error: Call to undefined function pipi() in [...][...]

while($x.=pi)$x();

यह मेरे पुराने उत्तर के समान है।


पुराना उत्तर, 20 बाइट्स

PHP आपको वेतन वृद्धि ऑपरेटर का उपयोग करके वर्णों को बढ़ाने की अनुमति देता है। यह केवल a-zसीमा पर काम करता है , लेकिन पर्याप्त है।

for($x=pi;;)$x=$x();

मेरा मानना ​​है कि यह सभी आवश्यक बिंदुओं को पूरा करता है और लूप एक बार चलता है।

आप देख सकते हैं क्योंकि आपको त्रुटि मिलेगी Fatal error: Function name must be a string


यह कैसे काम करता है, कदम से कदम:

  • निरुपित piकरने के लिए $x
    चूंकि piएक स्थिरांक के रूप में उपयोग किया जा रहा है, PHP मौजूद होने पर जांच करेगा।
    चूंकि यह नहीं है, PHP एक चेतावनी कहती है Use of undefined constant pi - assumed 'pi'(मूल रूप से: चूंकि निरंतर अस्तित्व में नहीं है, इसलिए इसे एक स्ट्रिंग माना जाता है)
  • पहली बार लूप
    • फ़ंक्शन को चलाएं $x()
      चूंकि $xइसका मूल्य है pi, यह फ़ंक्शन चलाएगा pi()
  • में मूल्य संग्रहीत करें $x
    $xअब इसके बजाय instead हैpi
  • दूसरी बार लूप
    • फ़ंक्शन को चलाएं $x()
      चूंकि Since $xहै, यह फ़ंक्शन चलाएगा 3.14159...()
    • π एक स्ट्रिंग नहीं है, इस बिंदु पर कार्यक्रम को मार रहा है Fatal Error

फ़ंक्शन खोजने के लिए @Titus के लिए धन्यवाद pi(), मुझे 1 बाइट की बचत !


एक अच्छा है, लेकिन मुझे नहीं लगता कि यह वैध है। यह वास्तव में एक बार लूप नहीं चलाता है। लूप बॉडी के चलने $xसे abtपहले आप वृद्धि करते हैं । आप लूप के बाद वृद्धि करके इसे ठीक कर सकते हैं ।
aross

मैं एक के बारे में सोचा अलग दृष्टिकोण
aross

@ सकल दुह, आप सही कह रहे हैं, यह मान्य नहीं था। वेतन वृद्धि गलत जगह पर है। यह वैसा ही काम कर रहा है जैसा अभी होना चाहिए। आप for($x=abs;;++$x)echo$x,$x();परीक्षण करने के लिए चलाने की कोशिश कर सकते हैं । यह दिखाना चाहिए abs0abt Fatal error[...]। या इसी के समान।
इस्माइल मिगुएल

1
आप piइसके बजाय उपयोग कर सकते हैं abs। इससे पहले कि यह घातक फेंकता है एक चेतावनी भी नहीं देता है।
तैतस

@ मैं पूरी तरह से उस समारोह के बारे में भूल गया! मुझे पता है कि फ़ंक्शन _कुछ प्रणालियों में परिभाषित है, लेकिन अविश्वसनीय है। लेकिन उस खोज के लिए धन्यवाद!
इस्माइल मिगुएल

10

GNU sed , 15 13 5 बाइट्स

-2 seshoumara
के लिए धन्यवाद -8 zeppelin के लिए धन्यवाद

H;G;D
  1. एक न्यूलाइन और होल्ड स्पेस को पैटर्न स्पेस पर लागू करता है।
  2. होल्ड स्थान पर एक नई रेखा और पैटर्न स्पेस लागू करता है।
  3. पहले न्यूलाइन तक हटाता है और शुरू होता है।

यह जल्दी से स्मृति से बाहर चलाता है:

$ time (echo|sed 'H;G;D')
sed: couldn't re-allocate memory

real    0m1.580s
user    0m0.545s
sys     0m1.012s

हाय, कैसे s:a\?:&a:g? यह 1 बाइट कम है और प्रति पुनरावृत्ति प्रति पैटर्न आकार को भी दोगुना करता है।
शीशमारा

@seshoumara मुझे नहीं लगता कि पैटर्न स्पेस खाली होने पर कुछ भी मेल खाएगा, इसलिए यह पहला प्रतिस्थापन कभी नहीं करेगा।
रिले

@ शेशमौरा echo -n | sed 's:a\?:&a:g'और कोई आउटपुट नहीं मिला। यह वही sed 's::a:'होगा जो किसी भी चीज से मेल नहीं खाएगा।
रिले

साथ echo -nकुछ नहीं sed के लिए पारित किया है, लेकिन sed डिजाइन द्वारा इनपुट के बिना शुरू नहीं कर सकते हो जाता है। यह देखने के लिए इस मेटा लिंक की जाँच करें कि echo|sedकोई इनपुट नियम लागू करने वाली चुनौतियों के लिए sed शुरू करने का स्वीकृत तरीका है।
शीशमारा

@ शीशमौरा मुझे लगा कि यह अभी भी एक खाली स्ट्रिंग देगा। तब काम करने लगता है। धन्यवाद!
रिले

9

आर, 22 25 22 20 18 बाइट्स

संपादित करें: यह इंगित करने के लिए @Mego का धन्यवाद कि R टेल कॉल ऑप्टिमाइज़ेशन का समर्थन नहीं करता है।

Edit4: एक और भी छोटा सा घोल मिला जो अभी तक काफी जटिल है।

repeat(ls(T<-T-1))

उत्तर बिलियन बूलियन ट्रू चर का उपयोग करता है, Tजिसे दोहराए जाने वाले लूप में अनिश्चित काल तक घटाया जाता है। फ़ंक्शन ls()को प्रत्येक पुनरावृत्ति कहा जाता है जो वर्तमान वातावरण में सभी वस्तुओं को सूचीबद्ध करता है। हालाँकि, पहला तर्क nameनिर्दिष्ट करता है कि किस वातावरण से वस्तुओं को सूचीबद्ध किया जाए। आर-प्रलेखन से हम पाते हैं कि:

नाम तर्क पर्यावरण को निर्दिष्ट कर सकता है जिसमें से ऑब्जेक्ट नामों को कई रूपों में से एक में लिया जाता है: एक पूर्णांक ( searchसूची में स्थिति ) के रूप में; खोज सूची में एक तत्व के चरित्र स्ट्रिंग नाम के रूप में; या एक स्पष्ट environment( sys.frameवर्तमान में सक्रिय फ़ंक्शन कॉल का उपयोग करने सहित )।

इसका मुख्य अर्थ यह है कि पहले पुनरावृत्ति में हम चलते ls(-1)हैं character(0)( जो everything-except-the-firstकिसी भी वर्ण प्रकार के गैर-मौजूद तत्व तक पहुंचने की कोशिश करते समय मानक होता है )। दूसरी पुनरावृत्ति के दौरान, Tदो से घटाया जाता है और हम बाद में कॉल करते हैं ls(-3)जो बदले में त्रुटि देता है:

Error in as.environment(pos) : invalid 'pos' argument

ऐसा इसलिए है क्योंकि हम everything-except-the-thirdतत्व को सूचीबद्ध करने का प्रयास करते हैं लेकिन स्थानीय वातावरण में केवल Tइस बिंदु पर चर होता है (जैसे, इस पुनरावृत्ति पर ls()लंबाई की सूची लौटाएगा 1) और एक त्रुटि वापस आ जाती है।


1
अगर रिकर्सन सीमा नहीं है, तो पूंछ कॉल अनुकूलन के साथ पुनरावृत्ति की तरह ध्वनि नहीं होती है।
मेघ

@ मैगो के आसपास कुछ खुदाई के बाद मुझे पता चला कि आर वास्तव में टेल कॉल ऑप्टिमाइज़ेशन का समर्थन नहीं करता है, इसलिए यह उत्तर मान्य नहीं है (अवधारणा से पहले कभी नहीं सुना)। एक पल में मान्य उत्तर में बदल जाएगा।
बिलीवॉब

9

Befunge-93, 3 बाइट्स (संभवतः 1 या 0)

!%!

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

लूप के पहले पुनरावृत्ति पर, स्टैक खाली है, जो सभी शून्य के बराबर है। !(नहीं) आपरेशन इस प्रकार 1 के लिए ढेर शीर्ष बदल देता है, और %(सापेक्ष) आपरेशन 0 आधुनिक 1 की गणना करता है, 0. अगले छोड़ने !आपरेशन धर्मान्तरित 0 1 करने से पहले कार्यक्रम काउंटर इर्द-गिर्द घूमती है और पाश फिर से शुरू होता है।

दूसरी पुनरावृत्ति पर, पहला !ऑपरेशन 1 को परिवर्तित करता है जो अब स्टैक के शीर्ष पर 0. है। %ऑपरेशन तब 0 मॉड 0 की गणना करता है, जो संदर्भ दुभाषिया पर शून्य त्रुटि से एक डिवीजन उत्पन्न करता है, और इस प्रकार प्रोग्राम को समाप्त करता है।

वहाँ भी अधिक उबाऊ 1 बाइट उत्तर है, हालांकि मुझे यकीन नहीं है कि यह वैध माना जाता है।

"

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

यह "कमांड एक स्ट्रिंग शुरू करता है, इस प्रकार बाकी लाइन पर प्रत्येक स्थान को स्टैक पर धकेल दिया जाता है जब तक कि प्रोग्राम काउंटर चारों ओर से घूमता है और "फिर से स्ट्रिंग को बंद करने का सामना करता है । फिर दूसरी प्रक्रिया शुरू करने के लिए इसे दूसरी बार लपेटने की आवश्यकता होगी और दूसरी स्ट्रिंग को शुरू करने और स्टैक पर अन्य 79 स्थानों को धकेलने की आवश्यकता होगी। अंततः यह या तो मेमोरी से बाहर चलेगा (संदर्भ दुभाषिया व्यवहार) या स्टैक ओवरफ्लो का उत्पादन करेगा।

अब अगर आप वास्तव में नियमों को आगे बढ़ाना चाहते हैं तो तकनीकी रूप से एक शून्य बाइट समाधान भी है।


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

कितनी तेजी से होता है यह कंप्यूटर की गति, उपलब्ध मेमोरी और उपयोग किए जा रहे ब्राउज़र पर निर्भर करेगा। अपनी मशीन पर मैंने पाया कि Microsoft Edge ने सबसे अच्छा काम किया, लेकिन तब भी यह दो मिनट के बाद 500MB का उपयोग करके "केवल" था। यह पंद्रह मिनट के निशान (इस्तेमाल किए गए कई गीगाबाइट के साथ) के आसपास तक नहीं था कि एज ने प्रक्रिया को मारने और टैब को ताज़ा करने का फैसला किया। इसलिए इसे दो मिनट की समय सीमा के तहत बनाने की संभावना नहीं है, लेकिन सही परिस्थितियों के साथ जो जरूरी नहीं कि प्रश्न से बाहर हो।


8

FALSE, 8 बाइट्स

मुझे यह भाषा बहुत पसंद है।

1[$][.]#

यह एक धक्का देता है 1, तब [$][.]#लूप होता है जबकि $यह सच है (स्टैक के डुप्लिकेट टॉप) और ( .) इसे आउटपुट करता है। एकल के छपने के बाद यह दुभाषिया दुर्घटनाग्रस्त हो 1जाता है (कम से कम एक बार चलने वाले लूप का प्रमाण।) इस दुभाषिया में एक बग लगता है। निम्नलिखित 9-बाइट कार्यक्रम को सभी अनुरूप दुभाषियों में काम करना चाहिए:

1[$][..]#

आपको DUP को भी आज़माना चाहिए, जो मूल रूप से FALSE का सुपरसेट है। यही मैंने RETURN बनाने के लिए उपयोग किया।
मामा फन रोल

@MamaFunRoll ओह, हाँ, मैं भूल गया कि आपने रिटेन किया है! मुझे लगता है कि एक कोशिश करनी चाहिए। : डी
कॉनर ओ'ब्रायन

@MamaFunRoll मुझे DUP से प्यार है, मैंने अभी एक DUP दुभाषिया लिखा है और मैं इसके साथ खेल रहा हूँ।
ML

@ कॉनरोर ब्रायन: मैं कहूंगा कि आपका पहला समाधान किसी भी दुभाषिए को दुर्घटनाग्रस्त कर सकता है। मैंने सिर्फ अपने स्वयं के दुभाषिया के साथ एक डिबग रन बनाया है, और यह स्पष्ट है कि पहले .डेटा स्टैक को खाली करता है, जबकि दूसरे लूप $में खाली स्टैक के शीर्ष तत्व की नकल करने की कोशिश करता है, जिससे त्रुटि हो सकती है (ठीक है, मेरा दुभाषिया करता है) )। दूसरा संस्करण मान्य नहीं होना चाहिए क्योंकि यह पहले लूप को भी पूरा नहीं करता है क्योंकि यह पहले से ही खाली स्टैक तक समय से पहले पहुंचने की कोशिश करता है।
ML

अपने दूसरे उदाहरण के लिए, यहां मेरे डीयूपी दुभाषिया का एक पूर्ण रंगीन डिबग डंप है। हालांकि यह स्पष्ट है कि डेटा स्टैक (ds) और रिटर्न स्टैक (rs) कैसे काम करते हैं, बाद वाला FALSE में पारदर्शी नहीं है, हालाँकि।
एम एल

8

सी, 21 बाइट्स

i;f(){for(;1/!i++;);}

यहाँ के iरूप में शुरू करने की गारंटी है 0

यह पुष्टि की जा सकती है कि यह एक बार ऐसा चलता है:

i;f(){for(;1/!i++;)puts("hi");}
main(){f();}

जो, मेरी मशीन पर, परिणाम:

llama@llama:...code/c/ppcg104323loop$ ./a.out 
hi
zsh: floating point exception (core dumped)  ./a.out

सबसे छोटा पुनरावर्ती समाधान मैं 22 बाइट्स पा सकता हूं :

f(i){f(i-puts(""-i));}

gccकेवल टेल कॉल का उन्मूलन -O2या उससे अधिक होता है, जिस बिंदु पर हमें किसी फ़ंक्शन को कॉल करने की आवश्यकता होती है, जिससे putsपूरी चीज़ को अनुकूलित होने से रोका जा सके। पुष्टि है कि यह काम करता है:

llama@llama:...code/c/ppcg104323loop$ cat loop.c       
main(){f();}
f(i){f(i-puts(""-i));}
llama@llama:...code/c/ppcg104323loop$ gcc -O2 -S loop.c 2>/dev/null
llama@llama:...code/c/ppcg104323loop$ grep call loop.s
    call    puts
    call    f

निम्नलिखित एक पूर्ण कार्यक्रम है, जो मानता है कि इसे 22 बाइट्स में कमांड लाइन तर्क के साथ नहीं बुलाया जाता है :

main(i){for(;1/i--;);}

जो समान लंबाई के कार्य के बराबर है:

f(i){for(i=1;1/i--;);}

क्या इस तरह का एक कार्य मुख्य जैसा माना जाता है? यदि यह है, तो पहला तर्क तर्क सूची की लंबाई है (जो कि 1 है, नाम जिसे इसे कॉल करने के लिए उपयोग किया गया था)।
रिले

या, तर्क रजिस्टर में अभी भी वह मूल्य है जो मुख्य कहे जाने से था।
रिले

@ रिले आह, बाद का सिद्धांत ऐसा प्रतीत होता है, जैसा कि इस तथ्य से जाहिर होता है कि कमांड लाइन के तर्कों के रूप में संख्या बढ़ जाती है। अंतर्दृष्टि के लिए धन्यवाद!
दरवाज़े

मुझे यकीन नहीं था कि आप इसे मेरे पहले अनुमान में कैसे कह रहे हैं, लेकिन मुझे फ़ंक्शन के पहले तर्क के समान होना चाहिए जो एफ कहता है।
रिले


6

MATLAB, 18 बाइट्स

इसे स्क्रिप्ट के रूप में चलाया जा सकता है:

for j=1:2;j(j);end

पहला पुनरावृत्ति ठीक है, क्योंकि j(1)अभी है 1। दूसरी पुनरावृत्ति सीमा त्रुटि से सरणी के साथ क्रैश होती है, जैसा j(2)कि आयामों से अधिक है j, जो 1x1 सरणी है।

यह एक स्क्रिप्ट के रूप में भी चलाया जा सकता है, लेकिन यह केवल पहली बार काम करता है जब आप इसे चलाते हैं। फिर भी, यह MATLAB के पूर्वनिर्धारित स्थिरांक का एक उल्लसित पर्याप्त दुरुपयोग है जो मुझे लगा कि मैं इसे शामिल करूंगा। यह भी 18 बाइट्स है।

while i/i;i={};end

जब किसी कार्यक्षेत्र में चलाया जाता है जिसे चर iअभी तक परिभाषित नहीं किया गया है, तो यह iमाना जाता है कि यह काल्पनिक इकाई है, इसलिए i/i = 1। पहले लूप में, असाइनमेंट i={}एक खाली सेल ऐरे बनाता है जिसे कहा जाता है i। दूसरी पुनरावृत्ति पर, लूप टाइप "सेल 'के इनपुट तर्कों के लिए" अपरिभाषित ऑपरेटर' / 'से बाहर निकलता है। "


उन दोनों का कमाल है! आप शायद यह जानते हैं, लेकिन j(2)सामान्य रूप से 2-बाय -2 मैट्रिक्स देंगे0+1i
स्टीवी ग्रिफिन

धन्यवाद! यह सच है कि ऑक्टेव में नहीं बल्कि MATLAB में मुझे लगता है
मैट 11H

6

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

loop {5[$++]}

एक अनंत लूप में पूर्णांक शाब्दिक अनुक्रमित करता है।
इस तथ्य पर निर्भर करता है कि स्केलर मूल्यों पर, सरणी अनुक्रमणिका सिंटैक्स का उपयोग सूचकांक के साथ किया जा सकता है 0(स्वयं मूल्य वापस), लेकिन Index out of rangeकिसी अन्य सूचकांक के लिए एक त्रुटि फेंकता है ।


6

QBasic, 17 बाइट्स

यह कोड बहुत अजीब है।

DO
i=11+a(i)
LOOP

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

QBasic में, वैरिएबल प्रीइंस्टीट्यूशनल होते हैं। किसी भी प्रकार के प्रत्यय के बिना एक नियमित चर, iयहां की तरह , शून्य से पूर्ववर्ती है।

सिवाय अगर आप उस चर की तरह एक सरणी में सब्स्क्राइब करने की कोशिश करते हैं ... जिस स्थिति में, यह 11 शून्य का एक सरणी है। *

लूप के माध्यम से पहली बार पर, इसलिए, iहै 0और aएक सरणी है। a(i)सरणी का शून्य तत्व देता है (जो है 0)। सब अच्छा और अच्छा। हम सेट iकरने के लिए 11और पाश। लेकिन अब 11सरणी के लिए एक वैध सूचकांक नहीं है a, और कार्यक्रम के साथ रुकता है Subscript out of range

एक 19-बाइट संस्करण जो बेहतर दिखाता है कि क्या हो रहा है:

DO
?a(i)
i=i+1
LOOP

यह 0इरेट करने से पहले ग्यारह बार प्रिंट करेगा ।


* अवधारणात्मक रूप से, यह 10-तत्व सरणी है। QBasic में अधिकांश चीजें 1-अनुक्रमित हैं, लेकिन एरे को संभवतः कार्यान्वयन कारणों से नहीं किया जाता है। प्रोग्रामर के लिए अपेक्षा के अनुसार काम करने के लिए, QBasic एक अतिरिक्त प्रविष्टि में फेंकता है ताकि आप सूचक 1 से 10. इंडेक्स 0 का उपयोग कर सकें, हालांकि, अभी भी पूरी तरह से सुलभ है। जाओ पता लगाओ।


QBasic और arrays, मज़ा कहाँ रुकता है!
steenbergh

के बाद से त्रुटि नहीं है है दूसरे लूप पर हो, तो आप नहीं कर सका i=1+a(i)?
Quelklef

@Quelklef नहीं, आपको करना होगा i=i+1+a(i)। अन्यथा सूचकांक कभी भी ऊपर नहीं जाता है 1, जो एक त्रुटि नहीं है।
DLosc

@ डलास ओह, तुम सही कह रहे हो।
क्वेलक्लेफ

5

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

f(a:b)=f b
f"a"

f"a"पहले चार को गिराकर स्ट्रिंग "ए" के माध्यम से पुनरावृत्ति करता है और अंततः एक Non-exhaustive patterns in function fअपवाद के साथ इसके अंत में विफल रहता है, क्योंकि fकेवल गैर-खाली तारों के लिए परिभाषित किया गया है।


5

सी #, 71 38 बाइट्स

चूँकि आपने C # में एक उदाहरण दिया था, जिसका एक और संस्करण गढ़ा गया था

और Pinkfloydx33 के लिए धन्यवाद

void c(){checked{for(uint i=1;;i--);}}

की तुलना में छोटा Parse.ToString()और यहां तक ​​कि Parse($"{c--}") मैं मानसिक रूप से checkedइसके लिए बहुत लंबे समय से एक खोजशब्द के रूप में फेंक दिया । मुश्किल से यह निश्चित रूप से कम हैParse(c.ToString())

मूल उत्तर

class p{static void Main(){for(int c=0;;c--)uint.Parse(c.ToString());}}

यह c=0तब शुरू होगा , जब c=-1इसका uint.Parseकारण होगा:

Unhandled Exception: System.OverflowException: Value was either too large or too small for a UInt32.

Ungolfed संस्करण और उस लूप को सत्यापित करने से कम से कम एक बार चलता है

class p {
    static void Main() {
        for(int c=0;;c--) {
            System.Console.Write(c);
            uint.Parse(c.ToString());
        }
    }
}

for(int c=0;;)uint.Parse($"{c--}");
Pinkfloydx33

1
checked{for(uint c=1;;)c--;}
Pinkfloydx33

ठीक है, वाह! '$' आशुलिपि के बारे में पता नहीं था!
MrPaulch

4

CJam , 4 बाइट्स

1{}g

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

खाली {}gलूप का पहला पुनरावृत्ति पॉप करता है 1, जो इसे जारी रखने के लिए कहता है। दूसरा पुनरावृत्ति एक और सशर्त पॉप करने की कोशिश करता है, लेकिन स्टैक खाली है, इसलिए प्रोग्राम क्रैश हो जाता है।


4

x86 असेंबली (एटी एंड टी सिंटैक्स), 40 बाइट्स

f:
mov $1,%eax
A:
div %eax
dec %eax
je A

एक फ़ंक्शन च को घोषित करता है जो 1 को 1 से 1 तक विभाजित करता है और फिर पहले 0 से 0 और त्रुटियों को विभाजित करने का प्रयास करता है।


इंटेल सिंटैक्स पर स्विच करके आप 4 बाइट्स बचा सकते हैं :)
mriklojn 1

6
हम आम तौर पर जनरेट किए गए बाइट कोड के आकार के अनुसार असेंबली स्कोर करते हैं, न कि मानव-पठनीय निर्देश।
डेनिस

@ डेनिस असेंबल्ड असेंबली मशीन लैंग्वेज है। लेकिन हाँ यह मशीन भाषा के रूप में बहुत कम दावा किया जा सकता है।
2

एफ-लेबल और mov से छुटकारा पाएं। डिक और डिव को स्वैप करें, और आप और भी अधिक छुटकारा पा सकते हैं।
क्लीयर

4

CJam, 4 बाइट्स

P`:~

P`स्ट्रिंग उत्पन्न करता है 3.141592653589793:~प्रत्येक चरित्र का मूल्यांकन करता है। 3सीजेएम में मान्य कोड है जो केवल 3 रिटर्न करता है। अगले पुनरावृत्ति में, .एक त्रुटि का कारण बनता है क्योंकि इसके लिए एक अंक या एक ऑपरेटर की आवश्यकता होती है।




4

बैच, 22 20 बाइट्स

:a
set i=%i%1
goto a

व्याख्या

यह एक अनंत लूप है 1जो शुरू में खाली स्ट्रिंग पर जोड़ता है । आखिरकार यह 8192 की अधिकतम स्ट्रिंग लंबाई और दुर्घटना को पार कर जाएगा। मेरी मशीन पर, यह लगभग 30 सेकंड लेता है।


अच्छा! आप यूनिक्स लाइन एंडिंग्स का उपयोग करके 2 बाइट्स बचा सकते हैं।
रिश्वतखोर

आप% 0 का उपयोग कर सकते हैं जो लेबल और गोटो के बजाय फ़ाइल नाम है।
YourDeathIsComing

मुझे यकीन नहीं था कि अगर पूंछ पुनरावृत्ति नियम को तोड़ दिया।
कुछ

4

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

for(;;i);

यह एक बार चलता है, फिर फेंकता है ReferenceError: i is not definedजो लूप को रोकता है।

// With a console.log(1) to see that it runs once.
for(;;i)console.log(1);


निम्नलिखित को एक उदाहरण के रूप में लेते हुए, <increment>पहले चक्र का अंत या दूसरे चक्र की शुरुआत है?

0:for(<init>;<test>;<increment>)
1:{
2:  <statement>;
3:}

1 / मैं इसे देखता हूं

लाइन 3 तो जा रहा लाइनों 0 से जाने के बाद वापस लाइन 0 पर, यह एक पूर्ण चक्र की तरह पूरा हो चुका है लगता है।
इससे <increment>दूसरे चक्र की शुरुआत होगी ।
- पहला चक्र: <init>-> <test>-> <statement>
- दूसरा चक्र: <increment>-> <test>-><statement>

2 / Whileसमकक्ष

0:<init>;
1:while(<test>)
2:{
3:  <statement>;
4:  <increment>;
5:}

इसके बराबर whileमें <increment>पहले चक्र का अंत है और ऐसा लगता है कि यह उसी के साथ समान है for
इससे <increment>पहले चक्र का अंत होगा ।
- पहला चक्र: <test>-> <statement>-> <increment>
- दूसरा चक्र: <test>-> <statement>-><increment>

3 / एक बयान दो बार सामना करना पड़ा है

एक बयान के दो बार सामना करने पर एक पूरा चक्र पूरा हो जाता है।
पहले बयान दो बार सामना करना पड़ा है <test>
इससे <increment>पहले चक्र का अंत होगा ।
- पहला चक्र: <test>-> <statement>-> <increment>
- दूसरा चक्र: <test>-> <statement>-><increment>

4 / यह एक सेटअप है

<init>बस स्थापित कर रही है जो कुछ भी पहले चक्र के लिए आवश्यक है। बस स्थापित कर रही है जो कुछ भी दूसरा चक्र के लिए आवश्यक है। इससे दूसरे चक्र की शुरुआत होगी । - पहला चक्र: -> -> - दूसरा चक्र: -> ->
<increment>
<increment>
<init as a setup><test><statement>
<increment as a setup><test><statement>


ECMAScript® 2016 भाषा की विशिष्टता

का रनटाइम for(<init>;<test>;<increment>)<statement>;

बता दें कि varDcl मूल्यांकन का परिणाम है <init>
ReturnIfAbrupt (varDcl)।
वापसी ? ForBodyEvaluation ( <test>, <increment>, <statement>, «», labelSet)।

तीन रूप हैं, इसलिए मैंने यहां सबसे छोटा लिया, कोई अंतर नहीं है:
- जो भी हो <init>यह पहली यात्रा का हिस्सा नहीं है।
- ForBodyEvaluation में क्या प्रासंगिक है।

ForBodyEvaluation का विवरण ( <test>, <increment>, <statement>, «», labelSet)

0 V को अपरिभाषित करते हैं।
1 प्रदर्शन? CreatePerIterationEnvironment (perIterationBindings)।
2 दोहराएं
3 अगर [खाली] नहीं है, तो
4 मूल्यांकन करने के लिए testRef का परिणाम दें <test>
5 टेस्टवील्यू होने दें? GetValue (testRef)।
6 अगर टूबलियन (टेस्टवैल्यू) गलत है, तो नॉर्मलकंप्लीशन (वी) लौटाएं।
7 मूल्यांकन के परिणाम दें <statement>
8 यदि लूपकॉप्ट्स (परिणाम, लेबलसेट) गलत है, तो पूर्णता लौटाएं (अपडेटइम्टी (परिणाम, वी))।
9 यदि परिणाम है। [[मूल्य]] खाली नहीं है, तो वी को परिणाम दें। [[मूल्य]]।
10 प्रदर्शन? CreatePerIterationEnvironment (perIterationBindings)।
11 यदि वह [खाली] नहीं है, तो
12 मूल्यांकन करने का परिणाम होने दें <increment>
13 प्रदर्शन? GetValue (incRef)।

6 / मैं इसे देखता हूं

एक पूर्ण चक्र दोहराए जाने वाले भाग का एक पूर्ण भाग है।
इससे <increment>पहले चक्र का अंत होगा ।
- पहला चक्र: <test>-> <statement>-> <increment>/ दूसरे शब्दों में लाइन 3 से लाइन 13 तक
- दूसरा चक्र: <test>-> <statement>-> <increment>/ / दूसरे शब्दों में लाइन 3 से लाइन 13 तक

7 / एक चक्र एक पुनरावृत्ति है

एक चक्र से शुरू होता है CreatePerIterationEnvironment
इसलिए जब CreatePerIterationEnvironmentएक नया चक्र शुरू होता है, तो यह पहले वाले को समाप्त कर देता है।
इससे <increment>दूसरे चक्र की शुरुआत होगी ।
- पहला चक्र: <test>-> <statement>/ दूसरे शब्दों में पंक्ति 1 से पंक्ति 9 तक
- दूसरा चक्र: <increment>-> <test>-> <statement>/ पंक्ति 10 से दूसरे शब्दों में पंक्ति 9 तक


क्या <increment>पहले चक्र का अंत है या दूसरे चक्र की शुरुआत है?

सही स्पष्टीकरण या तो 6 या 7 है।


8
मुझे लगता है कि मैं पहले पुनरावृत्ति के अंत में वृद्धि के लिए इच्छुक हूं, न कि दूसरी पुनरावृत्ति की शुरुआत की तुलना में या न ही पुनरावृत्ति के लिए। मुझे लगता है कि यह सवाल की अस्पष्टता है।

1
चूँकि for(a;b;c)d;, लगभग बराबर है a;while(b){d;c;}, मैं यह कहना चाह रहा हूँ कि त्रुटि अभी भी पहले पुनरावृत्ति में फेंकी गई है (लूप की स्थिति को दूसरी बार जाँचने से पहले)।
ETHproductions

@ हर्किल पहला पुनरावृत्ति आरंभीकरण के साथ शुरू होता है, इसलिए मुझे लगता है कि वेतन वृद्धि दूसरी मध्यस्थता की शुरुआत होनी चाहिए।
हेडी

4
यदि आप युक्ति पढ़ते हैं , तो आप देख सकते हैं कि वेतन वृद्धि पुनरावृत्ति का अंतिम भाग है और जैसे कि, अभी भी पहले पुनरावृत्ति में है।
लीख

3
@ हेदी मैं नहीं देखता कि यह कैसे प्रासंगिक है। वेतन वृद्धि ऑपरेशन स्पष्ट रूप से लूप के पहले रन का एक हिस्सा है। Rephrase करने के लिए, जब वेतन वृद्धि ऑपरेशन कहा जाता है, तो लूप एक पूर्ण रन समाप्त नहीं हुआ है।
नित

4

INTERCAL , 12 बाइट्स

(1)DO(1)NEXT

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

NEXTINTERCAL-72 का मुख्य नियंत्रण प्रवाह कमांड है। (बाद में संशोधन पेश किए COME FROMगए, जो अधिक प्रसिद्ध हो गए, लेकिन यह भाषा के मूल संस्करण में नहीं था; और सभी समाप्त किए गए INTERCAL कार्यान्वयन मैं NEXTबैकवर्ड संगतता के लिए समर्थन के बारे में जानते हैं , सभी के लिए लेकिन डिफ़ॉल्ट रूप से इसके लिए समर्थन सक्षम करना। मुझे विशेष रूप से शीर्षक में INTERCAL-72 नाम की आवश्यकता महसूस नहीं होती है।)

NEXTलूप बनाने के लिए उपयोग करते समय , आपको उस स्थान को खाली करने के लिए उपयोग करना चाहिए RESUMEया FORGETउस स्थान को खाली करने के लिए, जो यह याद रखने के लिए उपयोग करता है कि कार्यक्रम कहां है; RESUMEretroactively NEXTएक फंक्शन कॉल के लिए कुछ को सक्रिय करता है (हालांकि आप अपने द्वारा किए जा रहे कार्यों के अलावा अन्य कार्यों से वापस आ सकते हैं) जबकि FORGETयह कुछ गोटो स्टेटमेंट के समान है। यदि आप या तो ऐसा नहीं करते हैं (और यह प्रोग्राम नहीं करता है), तो कार्यक्रम 80 पुनरावृत्तियों के बाद दुर्घटनाग्रस्त हो जाएगा (यह व्यवहार वास्तव में INTERCAL विनिर्देश में निर्दिष्ट है)।

यह कुछ अस्पष्ट है कि क्या यह अनबिकेड रिकर्सन के रूप में गिना जाता है (प्रश्न में अस्वीकृत); आप निश्चित रूप से NEXTफ़ंक्शन कॉल को लागू करने के लिए इस प्रकार का उपयोग कर सकते हैं , जिस स्थिति में यह प्रभावी रूप से एक पुनरावर्ती फ़ंक्शन होगा, लेकिन यहां यह निर्धारित करने के लिए पर्याप्त जानकारी नहीं है कि हम फ़ंक्शन कॉल कर रहे हैं या नहीं। कम से कम, मैं इसे वैसे भी पोस्ट कर रहा हूं क्योंकि यह नियमों का उल्लंघन नहीं करता है, और एक INTERCAL कार्यान्वयन जो "टेल कॉल" को अनुकूलित करता है, न केवल विनिर्देश का उल्लंघन करेगा, बल्कि सबसे मौजूदा कार्यक्रमों को तोड़ने का कारण बन सकता है, क्योंकि से लौट रहा है "गलत फ़ंक्शन" एक IF स्टेटमेंट के बराबर करने का मुख्य तरीका है।

यहां सी-INTERCAL द्वारा उत्पन्न परिणामी त्रुटि संदेश है:

ICL123I PROGRAM HAS DISAPPEARED INTO THE BLACK LAGOON
    ON THE WAY TO 1
        CORRECT SOURCE AND RESUBNIT

(ध्यान दें कि दूसरी पंक्ति एक टैब के साथ, और आठ रिक्त स्थान के साथ तीसरी है। यह टर्मिनल में सही दिखता है, या बहुत अधिक किसी भी प्रोग्राम में टैब स्टॉप्स 8 के गुणक पर होता है। हालांकि, मार्कडाउन में टैब स्टॉप के गुणकों पर होता है। चार, मान्यताओं का उल्लंघन करते हुए कि अधिकांश पुराने कार्यक्रम टैब के बारे में बनाते हैं, इसलिए त्रुटि संदेश यहां थोड़ा विकृत है।)


क्या वास्तव में त्रुटि कहती है CORRECT SOURCE AND RESUBNIT? मूल C-INTERCAL त्रुटि संदेश में टाइपो के रूप में?
आंद्रकिस

1
@ ऑन्द्राकिस: हाँ, यह करता है। उस टाइपो को वर्षों से सावधानीपूर्वक संरक्षित किया गया है।

3

अजगर, 3 बाइट्स

W1w

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

W1सिर्फ while 1:पायथन में है। लूप बॉडी STDIN से पढ़ी गई एक लाइन को प्रिंट करती है, जो कोड को खाली इनपुट के साथ चलाने पर दूसरी पुनरावृत्ति के लिए क्रैश हो जाती है।

यदि लूप का उपयोग कर # (लूप-ए-एरर) पर प्रतिबंध लगा दिया गया है (मैं ऐसा मानता हूं), तो मुझे लगता है कि यह सबसे छोटा है जो इसे प्राप्त कर सकता है।


3

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

i=1
def x(n):del i;x(i)
x(i)

वास्तव में सरल। एक्स के लिए दूसरी कॉल पर, मैं वहां नहीं हूं, और अजगर इसके बारे में शिकायत करता है।


3

भूलभुलैया , 3 बाइट्स

#(/

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

अधिकांश 2D भाषाओं की तरह, भूलभुलैया में कोई स्पष्ट लूपिंग निर्माण नहीं है। इसके बजाय, कोई भी कोड जो इस तरह से निर्धारित किया गया है कि उसे कई बार निष्पादित किया जाता है, इन भाषाओं में एक लूप है। भूलभुलैया के मामले के लिए, एक सरल रैखिक कार्यक्रम एक लूप के रूप में कार्य करता है, क्योंकि अनुदेश सूचक उस पर आगे और पीछे उछाल देगा। यदि कार्यक्रम abc(कुछ आदेशों a, bऔर c) के लिए है, तो वास्तविक निष्पादन होगा abcbabcbabcb...इसलिए यह abcbएक अनंत लूप में चलता है।

इस विशेष कार्यक्रम के लिए इस लूप के दूसरे पुनरावृत्ति पर क्रैश होने के कारण, यहां व्यक्तिगत कमांड क्या करते हैं। ध्यान दें कि लेबिरिंथ के ढेर में तल पर शून्य की एक अंतर्निहित अनंत राशि होती है:

#   Push stack depth.   [... 0]
(   Decrement.          [... -1]
/   Divide.             [... 0]
(   Decrement.          [... -1]
#   Push stack depth.   [... -1 1]
(   Decrement.          [... -1 0]
/   Divide.             Crashes with division-by-zero error.

3

बैश, 11 (सीमावर्ती गैर-प्रतिस्पर्धात्मक)

exec $0 1$@

यह स्क्रिप्ट 1प्रत्येक पुनरावृत्ति पर पारित होने वाले आर्ग्स के लिए पुनरावर्ती रूप से खुद को निष्पादित करता है। मुझे लगता है कि यह TCO के रूप में गिना जाता है क्योंकि निष्पादन प्रक्रिया स्थान को पुन: उपयोग करता है लेकिन स्टैक नहीं खाता है। यह गैर-प्रतिस्पर्धात्मक है क्योंकि मेरी मशीन - YMMV पर मारे जाने से पहले लगभग 10 मिनट लगते थे।


1
exec $0 1$@$@ बहुत तेजी से समाप्त होता है, लेकिन दो वर्ण लंबा है।
2

3

सेमी, 34 बाइट्स

for /l %i in (0,1,10) do color %i0

यह %i0 से 10. तक चक्र होगा । (प्राचीन) colorकमांड किसी भी तर्क को खुशी से स्वीकार करेगा जिसमें 2 (हेक्सा-) दशमलव अंक हैं। तर्क के साथ 100यह विफल हो जाएगा, मदद संदेश को प्रिंट करना और ERRORLEVEL1 पर सेट करना।

कम से कम एक बार चलने वाले लूप का सबूत: आपके शेल का रंग अलग होगा!

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