लूप बिना 'लूपिंग' [बंद]

Question

इसी से मिलता-जुलता एक सवाल कुछ साल पहले पूछा गया है , लेकिन यह और भी पेचीदा है।

चुनौती सरल है। एक कार्यक्रम (पसंद का अपनी भाषा में) है कि बार-बार इस तरह के रूप में किसी भी पुनरावृत्ति संरचनाओं का उपयोग किए बिना कोड निष्पादित लिखें while, for, do while, foreachया goto( तो तुम सब nitpickers के लिए, आप एक पाश उपयोग नहीं कर सकते )। हालांकि, फ़ंक्शन को स्वयं को समझ में लेने वाले फ़ंक्शन में पुनरावृत्ति की अनुमति नहीं है (नीचे परिभाषा देखें) । इससे यह चुनौती बहुत आसान हो जाएगी।

लूप को निष्पादित करने की आवश्यकता पर कोई प्रतिबंध नहीं है, लेकिन अपने उत्तर के साथ एक स्पष्टीकरण पोस्ट करें ताकि दूसरों को ठीक से समझ में आ सके कि क्या लागू किया जा रहा है।

उन लोगों के लिए जिन्हें परिभाषाओं पर लटका दिया जा सकता है, इस प्रश्न के लिए एक लूप की परिभाषा है:

A programming language statement which allows code to be repeatedly executed.

और इस प्रश्न के लिए पुनरावृत्ति की परिभाषा आपके मानक पुनरावर्ती कार्य की परिभाषा होगी:

A function that calls itself.

विजेता उत्तर होगा जो 16 जुलाई को सुबह 10 बजे पूर्वी समय में सबसे ऊपर होगा। सौभाग्य!

अपडेट करें:

भ्रम को शांत करने के लिए जो अभी भी व्यक्त किया जा रहा है, इससे मदद मिल सकती है:

ऊपर बताए गए नियम:

• छोरों या गोटो का उपयोग न करें
• कार्य स्वयं नहीं कह सकते
• 'पाश' में आप जो चाहें करें

यदि आप कुछ लागू करना चाहते हैं और नियम स्पष्ट रूप से इसे अस्वीकार नहीं करते हैं, तो आगे बढ़ें और इसे करें। कई जवाब पहले ही नियमों को झुका चुके हैं।

Comments

उन लोगों के लिए जो एक आसान ट्रिक चाहते हैं, मुझे इसे पोस्ट करने की जहमत नहीं उठानी चाहिए: P बस 2 फ़ंक्शन करें, function Aकॉल करें function Bऔर function Bकॉल करें function Aजबकि 1 फ़ंक्शन कुछ करता है। चूंकि फ़ंक्शन खुद को कॉल नहीं करता है इसलिए इसे मानदंडों के आधार पर वैध होना चाहिए। ^

— Teun Pronk

"रचनात्मकता पर ध्यान केंद्रित करने के लिए लोकप्रियता प्रतियोगिता में बदलाव" सवाल को धोखा देना है!

— कज़िन कोकीन

"पुनरावृत्ति" की परिभाषा बहुत उपयोगी नहीं है। पुनरावर्ती कार्यों को अस्वीकार करना बेहतर होगा , जो ऐसे कार्य हैं जो स्वयं को प्रत्यक्ष या अप्रत्यक्ष रूप से संदर्भित करते हैं।

— lrn

क्या स्पष्ट नहीं है पाश निर्माण और पुनरावृत्ति की "परिभाषा" है। न ही बहुत सटीक हैं। उदाहरण: rep(f){f();f();}- यह एक बयान है (कुछ भाषाओं में एक फ़ंक्शन घोषणा एक बयान है) जो कोड को बार-बार निष्पादित करने की अनुमति देता है। क्या यह अस्वीकृत है। आप लूप को लागू करने के लिए कोड मांगते हैं। यदि वह कोड वाक्यात्मक रूप से एक कथन है, तो आपने इसे अस्वीकृत कर दिया है। एक और उदाहरण f(b) { b(); g(b); }; g(b) { f(b); }:। मैं कहूंगा fकि एक पुनरावर्ती कार्य है (पारस्परिक रूप से पुनरावर्ती होने से g)। क्या यह अस्वीकृत है?

— lrn

@CailinP, जो मैं "पर लटका हुआ हूं" वह यह है कि साइट पर सवाल साइट के लिए विषय पर होना चाहिए: इसका मतलब है कि एक स्पष्ट, उद्देश्य विनिर्देशन है, जो यह प्रश्न नहीं करता है।

— पीटर टेलर

Answer 1

माणिक

def method_missing(meth,*args)
  puts 'Banana'
  send(meth.next)
end

def also
  puts "Orange you glad I didn't say banana?"
end

ahem

डेमो

अपने गले को साफ करता है, "केले" को 3070 बार प्रिंट करता है, और "ऑरेंज आपको खुशी है कि मैंने केला नहीं कहा"।

यह रूबी की हास्यास्पद सिर्फ-इन-टाइम विधि परिभाषा कार्यक्षमता का उपयोग करता है, जो कि 'अहम' और 'भी' ("अहम", "अणे", "ऐहो", "एहीप", "ऐहक" शब्दों के बीच वर्णक्रम को परिभाषित करने वाली हर विधि को परिभाषित करता है। पहले केले को प्रिंट करने के लिए "एहर", "ऐश", "एंथ", "ऐहु", "ऐहेव" ...) और फिर सूची में अगला कॉल करें।

Comments

यह अंततः "भी" हिट करता है, जिसे परिभाषित किया गया है, और इसलिए गायब नहीं है।

— हिस्टोक्रैट

यह हिस्टेरिकल है।

— माइकल बी

@barrycarter: रूबी में String#next, जिसे method_missingअधिक या कम कार्यों में कहा जाता है जैसे कि एक संख्या को 1 से जोड़ना जैसे कि यह सभी अल्फ़ान्यूमेरिक वर्णों के साथ काम करता है (और गैर-अलनम्स यदि वे स्ट्रिंग में केवल वर्ण हैं)। देखें ruby-doc.org/core-2.1.2/String.html#method-i-next

— 3Doubloons

@NickT यह एक्सएमएल बिल्डरों जैसी कक्षाओं में प्रयोग करने योग्य है जहाँ आप केवल द्वारा बनाया गया कोई भी टैग लगा सकते हैं b.my_tag। इसका उपयोग ActiveRecord मॉडल या में भी किया जाता है OpenStruct। 'वॉट टॉक' में वह कहते हैं कि वैश्विक method_missingखराब है, लेकिन स्कोप भयानक है।

— हौलेथ

मुझे एक और रूबी कार्यक्रम पर एक पुरानी टिप्पणी याद है: "मुझे यह पसंद है क्योंकि यह मेथ है"

— विद्या सागर

Answer 2

अजगर - 16

या किसी भी अन्य भाषा के साथ।

exec"print 1;"*9

Comments

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

— सेलिनप

यह एक स्ट्रिंग ( "print 1;") लेता है , इसे 9 बार *9दोहराता है ( ), फिर परिणामी स्ट्रिंग को निष्पादित करता है ( exec)। वास्तव में सभी को लूप किए बिना कोड का एक हिस्सा दोहराना।

— स्क्रैगर

स्ट्रिंग गुणन के लिए याय!

— ठाणे ब्रिम्हल

इसके अलावा रूबी में काम करता है अगर आप को बदलने execके लिए eval याprint करने के लिए echo।

— अजादि32

Answer 3

सी तेज

मैंने कोड को और अधिक पढ़ने योग्य फैशन में विस्तारित किया है क्योंकि यह अब कोड गोल्फ नहीं है और एक वृद्धि काउंटर जोड़ा ताकि लोग वास्तव में देख सकें कि यह कार्यक्रम कुछ करता है।

class P{
    static int x=0;
    ~P(){
        System.Console.WriteLine(++x);
        new P();
    }
    static void Main(){
        new P();
    }
}

(ऐसा कभी मत करो)।

प्रारंभ में हम Pकक्षा का एक नया उदाहरण बनाते हैं , जो जब प्रोग्राम जीसी से बाहर निकलने की कोशिश करता है, जो फाइनल को कॉल करता है जो Pकक्षा का एक नया उदाहरण बनाता है , जिसे जब वह साफ करने की कोशिश करता है तो एक नया बनाता है Pजिसे फाइनल कहते हैं। ।

कार्यक्रम अंत में मर जाता है।

संपादित करें: बेवजह यह मरने से पहले लगभग 45k बार चलता है। मुझे बिलकुल पता नहीं है कि GC ने मेरी मुश्किल अनंत लूप का कैसे पता लगाया, लेकिन यह किया। यह छोटा है ऐसा लगता है कि यह पता नहीं लगा और धागा सिर्फ निष्पादन के 2 सेकंड के बाद मारा गया था: https://stackoverflow.com/questions/24662454/how-does-a-garbage-collector-avoid-an -infinite लूप-यहाँ

Edit2: अगर आपको लगता है कि यह थोड़ा बहुत है जैसे कि रिकर्सन मेरे दूसरे समाधान पर विचार करें : https://codegolf.stackexchange.com/a/33268/23300

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

Comments

मुझे यह भी नहीं पता था कि C # में विध्वंसक थे। मुझे सिखाने के लिए +1।

— देखिए

@ TheRare, यह करता है, लेकिन वे प्रकृति में गैर-नियतात्मक हैं और एक कार्यक्रम के निष्पादन के दौरान कभी नहीं बुलाया जा सकता है। उन्हें आभासी पद्धति के ओवरराइड के रूप में लागू किया जाता है, Finalizeइसलिए उन्हें कभी-कभी कहा जाता है finalizer। वास्तविक C # में, आपको IDisposableपैटर्न का उपयोग करना चाहिए ।

— माइकल बी

ऐसा लगता है कि कुछ बिंदु पर एक समय-आउट होता है। मुझे नहीं लगता कि यह जीसी है जो आपके चक्र को रोक रहा है, लेकिन इसके बजाय ऑपरेटिंग सिस्टम यह निर्णय ले रहा है कि आपके कार्यक्रम को समाप्त होने में बहुत लंबा समय लग रहा है।

— LVBen

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

— माइकल बी

कुछ मामूली संशोधनों के साथ (कार्यक्रम को समाप्त नहीं होने देना, 1 पी ऑब्जेक्ट को जीसी पर जारी करना, और बार-बार जीसी को कॉल करना)। मैं इसे अनिश्चित काल तक चलाने के लिए प्राप्त कर सकता हूं।

— LVBen

Answer 4

Befunge

.

अच्छी पुरानी Befunge आउटपुट 0 (एक खाली स्टैक से) बहुत अधिक हमेशा के लिए, जैसा कि रेखाएं चारों ओर लपेटती हैं।

Comments

हा! मुझे इस तरह के

— टोटके

Answer 5

जे एस

(f=function(){ console.log('hi!'); eval("("+f+")()") })()

फन फन!

एक फ़ंक्शन जो स्वयं के समान शरीर के साथ एक और फ़ंक्शन बनाता है और फिर इसे चलाता है।

जब स्टैक सीमा समाप्त हो जाती है और पूरी चीज ढह जाती है तो यह अंत में हाय प्रदर्शित करेगा।

अस्वीकरण: आप अपने ब्राउज़र में कुछ भी नहीं कर पाएंगे जब तक कि स्टैक सीमा समाप्त नहीं हो जाती।

---

और एक और, अधिक बुराई :

function f(){ var tab = window.open(); tab.f = f; tab.f()}()

यह एक फ़ंक्शन बनाता है जो एक विंडो खोलता है, फिर उस विंडो के भीतर एक फ़ंक्शन बनाता है जो फ़ंक्शन की प्रतिलिपि है, और फिर इसे चलाता है।

अस्वीकरण: यदि आप पॉपअप खोलने की अनुमति देंगे तो इसे समाप्त करने का एकमात्र तरीका आपके कंप्यूटर को पुनरारंभ करना होगा

Comments

यह सुनिश्चित करने के लिए बहुत बुराई है;)

— सेलिनप जूल

@CailinP सुंदर यकीन के लिए eval।

— ११:१४ बजे सीके

मुझे लगता है कि आप fअपने दूसरे फ़ंक्शन के अंत में गायब हैं । यह }f()अंत में होना चाहिए ।

— चिराग भाटिया

दुर्भाग्य से, मैंने इसे देखा क्योंकि मैंने इसे आजमाया था। : पी

— चिराग भाटिया

-1 - यह सिर्फ रिकर्सन है।

— इमिबिज़

Answer 6

x86 असेंबली / डॉस

    org 100h

start:
    mov dx,data
    mov ah,9h
    int 21h
    push start
    ret

data:
    db "Hello World!",10,13,"$"

क्या मैंने कहा कि कोई उलट पूंछ की पुनरावृत्ति नहीं हुई? क्या मैंने?

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

retअनुदेश, एक समारोह से वापस जाने के लिए प्रयोग किया जाता है, वास्तव में स्टैक से वापसी पता (जो आम तौर इसी द्वारा वहां डाल दिया है पॉप call) और इसे करने के लिए कूदता है। यहां प्रत्येक पुनरावृत्ति पर हम pushलौटने से पहले स्टैक पर एंट्रीपॉइंट का पता देते हैं , इस प्रकार एक अनंत लूप उत्पन्न करते हैं।

Comments

मैं सोच रहा था कि क्या यह विधानसभा में संभव था।

— इयान डी। स्कॉट

अपने जोखिम पर ढेर के साथ मेस । यहाँ ड्रेगन हो ;-)

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

मैं इस एक के रूप में codegolf.stackexchange.com/a/34295/11259 को कॉल करने जा रहा था , लेकिन मुझे लगता है कि वास्तव में इसका पहला जवाब है

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

@DigitalTrauma: हाँ, मैंने अपनी प्रविष्टि पोस्ट करने के बाद देखा, लेकिन मैं मैडम मीम की तस्वीर से जुड़ी हुई थी। :-) सौभाग्य से कुछ अंतर हैं (उनका थोड़ा अधिक मोटापा है और 32 बिट लिनक्स पर काम करता है, खदान को सीधे डॉस पर खेला जाता है और कोई अन्य छलांग नहीं है), अगर किसी को कोई आपत्ति नहीं है तो मैं इसे यहां छोड़ दूंगा।

— मट्टियो इतालिया

@MatteoItalia नहीं मोटे तौर पर, बस भद्दा;) (ईटीओ "ईएक्सएक्स जोड़ें, 4" मुझे भी भ्रमित किया, मुझे ओपकोड आकार की तालिका नहीं मिली, इसलिए मैं सिर्फ जंगली आकार का अनुमान लगाता हूं)। मैंने इसे ऑनलाइन कंपाइलर में बनाया था जबकि मेरी कार्य परियोजना संकलन कर रही थी इसलिए यह बुरी तरह से दिखता है। "प्रारंभ:" का उपयोग करने का महान विचार।

— पीटी राइटर

Answer 7

जावा

XKCD से सीधे

यह एक माता-पिता और बच्चे के बीच पकड़ने का कभी न खत्म होने वाला खेल है!

का लक्ष्य CHILDके लिए सेट है PARENTऔर का लक्ष्य PARENTहै CHILD। जब PARENTकॉल करता है AIM, तो यह BALLकक्षा के उदाहरण को फेंकता है और इसे कैच स्टेटमेंट द्वारा पकड़ा जाता है। कैच स्टेटमेंट तब कॉल करता है PARENT.TARGET.AIMजहां लक्ष्य है CHILD। CHILDउदाहरण के लिए एक ही करता है और माता-पिता के लिए "गेंद वापस फेंकता है"।

Comments

मुझे वो कॉमिक्स पसंद हैं!

— डेरेक 會 會

बेहतर होगा यदि गेंद वास्तव में माता-पिता और बच्चे के बीच फेंकी जा रही हो। जैसे-गेंद को हमेशा एक ही "व्यक्ति" द्वारा फेंका और पकड़ा जाता है।

— Ajedi32

@ Ajedi32 यह वास्तव में प्रतीत होता है कि यह इसे आगे और पीछे फेंक देता है; माता-पिता TARGET बच्चे हैं, और बच्चे का लक्ष्य माता-पिता है। माता-पिता को निशाना बनाया जाता है, जो गेंद को फेंक देता है और बच्चे को निशाना बनाता है और गेंद फेंकता है, क्यू लूप

— एलेक्स कोलमैन

@AlexColeman यह कोड गेंद को हवा में फेंकने वाले माता-पिता के अनुरूप होता है, इसे पकड़ता है, फिर इसे उस बच्चे को सौंपता है जो गेंद को वापस माता-पिता को सौंपने से पहले ऐसा ही करता है, और इसी तरह।

— अजेडी 32

TARGET.AIM(B);विधि में कमांड AIMएक पुनरावर्ती कॉल है। तो यह "कार्य स्वयं को कॉल नहीं कर सकता" नियम का उल्लंघन करता है।

— थियोडोर नॉरवेल

Answer 8

बैश, 3 वर्ण

yes

हाँ बार-बार कंसोल पर 'y' लौटाएगा

संपादित करें: इस पंक्ति को संपादित करने के लिए सभी को प्रोत्साहित किया जाता है:

yes something | xargs someaction

(ओलिवियर दुलैक को धन्यवाद)

Comments

यह क्यों चलता रहेगा? यह सवाल नहीं सिर्फ यह पता लगाने की कोशिश क्यों im।

— त्यूं प्रैंक

@TeunPronk yesएक बैश कमांड है जो शब्द को तब तक हां में छापता है जब तक कि वह मारा नहीं जाता या धारा बंद नहीं हो जाती। अगर यह स्क्रीन पर लिख रहा है, तो यह कभी नहीं रुकेगा जब तक आप इसे मार नहीं देते। यह एक तरह का धोखा है, क्योंकि यह एक ऐसा आदेश है जो मूल रूप से प्रिंटफ पर लूप का होता है।

— स्क्रैगर

अधिक मज़ा yesकुछ अन्य लूप को रखने के लिए उपयोग करना होगा ।

— त्रिकली

@izkata: लेकिन फिर आप कर सकते हैं: yes something | xargs someactionकोई पुनरावृत्ति (आप भी जोड़ सकते हैं -n 1 से xargs करने के लिए केवल 1 "कुछ" प्रति पंक्ति, आदि)। Xargs का उपयोग अधिक जटिल व्यवहारों (यहां तक ​​कि जिनके पास हाँ आउटपुट के साथ कुछ भी करने के लिए नहीं है) के लिए रास्ता खोलता है

— ओलिवियर दुलैक

@ सागर आपको सिर्फ जवाब देना चाहिए था yes।

— डेव्यूलेस

Answer 9

सी, 35 वर्ण

main(int a,char**v){execv(v[0],v);}

कार्यक्रम स्वयं निष्पादित करता है। मुझे यकीन नहीं है कि इसे पुनरावृत्ति माना जाए या नहीं।

Comments

@mniip टेल पुनरावृत्ति, फिर, अगर यह प्रक्रिया स्तर पर लागू होता है

— इज़काता

@ इज़काटा टेल रिकर्शन अभी भी रिकर्सन है, लेकिन यह रिकर्सन नहीं है। पुनरावृत्ति का अर्थ है एक समारोह (या इस मामले में प्रक्रिया) को समाप्त करने के लिए स्वयं की एक और पुनरावृत्ति के लिए 'प्रतीक्षा'। इस स्थिति में, execमूल एक को बदलने के लिए नई प्रक्रिया का कारण बनता है, इसलिए कोई कॉल स्टैक नहीं है जो अंततः वापस आ जाएगा या अतिप्रवाह करेगा।

— मिलीन

@millinon अनुकूलन का समर्थन करने वाली भाषा में, पूंछ पुनरावृत्ति कॉल स्टैक में पिछली कॉल की execजगह लेती है, पिछली प्रक्रिया को कैसे प्रतिस्थापित करती है। यह या तो अतिप्रवाह नहीं होगा।

— इज़काता

@millinon सिर्फ सुपर पंडिताऊ होने के लिए और योजना प्रोग्रामिंग भाषा में इस चर्चा लंबे समय तक बाहर खींच करने के लिए, इस अनुकूलन है एक भाषा की सुविधा। यह अनुमान है कि यदि आप एक पूंछ-पुनरावर्ती कॉल करते हैं, तो दुभाषिया / संकलक को अंतिम स्टैक फ्रेम का पुन: उपयोग करना होगा। ऐसा इसलिए है क्योंकि स्कीम में बिल्ट-इन लूपिंग स्ट्रक्चर्स नहीं है, इसलिए स्कीम में लूप को लागू करने का एकमात्र तरीका पूंछ-पुनरावृत्ति करना है, और अगर आप कई बार लूप की कोशिश करने से ओवरफ्लो हो गए तो यह चूसना पसंद करेंगे :)

— ऑर्ड

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

— लेउशेंको

Answer 10

सी (जीसीसी बिल्डिंस के साथ - क्लैंग के साथ काम करने के लिए भी लगता है)

• कोई स्पष्ट छोरों
• कोई स्पष्ट गोटो नहीं
• कोई पुनरावृत्ति नहीं
• स्टैक के साथ बस पुराने जमाने के खिलवाड़ (बच्चों, पर्यवेक्षण के बिना घर पर यह कोशिश मत करो):

#include <stdio.h>

void *frameloop (void *ret_addr) {
    void **fp;
    void *my_ra = __builtin_return_address(0);

    if (ret_addr) {
        fp = __builtin_frame_address(0);
        if (*fp == my_ra) return (*fp = ret_addr);
        else fp++;
        if (*fp == my_ra) return (*fp = ret_addr);
        else fp++;
        if (*fp == my_ra) return (*fp = ret_addr);
        else fp++;
        if (*fp == my_ra) return (*fp = ret_addr);
        return NULL;
    } else {
        return (my_ra);
    }
}

int main (int argc, char **argv) {
    void *ret_addr;
    int i = 0;

    ret_addr = frameloop(NULL);
    printf("Hello World %d\n", i++);
    if (i < 10) {
        frameloop(ret_addr);
    }
}

स्पष्टीकरण:

• main()पहले कॉल करता है frameloop(NULL)। इस मामले में __builtin_return_address(), रिटर्न का पता (इन main()) प्राप्त करने के लिए बिलिन का उपयोग करें frameloop()। हम इस पते पर लौटते हैं।
• printf() यह दिखाने के लिए कि हम लूपिंग कर रहे हैं
• अब हम frameloop()पिछले कॉल के लिए रिटर्न एड्रेस के साथ कॉल करते हैं। हम वर्तमान रिटर्न पते के लिए स्टैक के माध्यम से देखते हैं, और जब हम इसे ढूंढते हैं, तो हम पिछले रिटर्न पते को प्रतिस्थापित करते हैं।
• हम फिर दूसरी frameloop()कॉल से लौटते हैं। लेकिन जब से रिटर्न पता ऊपर हैक किया गया था, हम अंत में उस बिंदु पर वापस लौटते हैं main()जहां पहली कॉल को वापस लौटना चाहिए। इस प्रकार हम एक लूप में समाप्त होते हैं।

स्टैक में वापसी पते की खोज बेशक लूप के रूप में क्लीनर होगी, लेकिन जो भी बिना किसी लूपिंग के लिए मैं कुछ पुनरावृत्तियों को नियंत्रित करता है।

आउटपुट:

$ CFLAGS=-g make frameloop
cc -g    frameloop.c   -o frameloop
$ ./frameloop 
Hello World 0
Hello World 1
Hello World 2
Hello World 3
Hello World 4
Hello World 5
Hello World 6
Hello World 7
Hello World 8
Hello World 9
$ 

Comments

अच्छा! मुझे आश्चर्य है कि उन कार्यों सी कल्पना का हिस्सा क्यों नहीं हैं? ; -डॉ

— ब्रायन मिंटन

@ ब्रायनमिंटन वास्तव में setjmp()/ के साथ समान होना चाहिए longjmp()। ये c मानक में नहीं हैं, लेकिन मानक पुस्तकालय में हैं । मुझे लगता है कि हालांकि आज मैन्युअल रूप से स्टैक को पिघलाया जा रहा है ;-)

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

@BrianMinton मेरा अनुमान है क्योंकि यह CPU स्पेक्स में है, जो इसे (हार्डवेयर) प्लेटफॉर्म पर निर्भर करता है। और यह उपयोग करने के लिए खतरनाक है जब स्टैकफ्रेम ऑटो-जनरेट किया जाता है, तो मुझे आश्चर्य नहीं होगा कि एवी ऐसे कोड के बारे में रोएगा। X86 asm संस्करणों के लिए इसे या इसे जांचें ।

— PTwr

Answer 11

हास्केल

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

data Strange a = C (Strange a -> a)

-- Extract a value out of 'Strange'
extract :: Strange a -> a
extract (x@(C x')) = x' x

-- The Y combinator, which allows to express arbitrary recursion
yc :: (a -> a) -> a
yc f =  let fxx = C (\x -> f (extract x))
        in extract fxx

main = yc (putStrLn "Hello world" >>)

समारोह extractकुछ भी फोन नहीं है, ycसिर्फ कॉल extractऔर mainसिर्फ कॉल ycऔर putStrLnऔर >>, जो पुनरावर्ती नहीं हैं।

स्पष्टीकरण: चाल पुनरावर्ती डेटा प्रकार में है Strange। यह एक पुनरावर्ती डेटा प्रकार है जो स्वयं का उपभोग करता है, जो कि उदाहरण में दिखाया गया है, मनमाना दोहराव की अनुमति देता है। सबसे पहले, हम निर्माण कर सकते हैं extract x, जो अनिवार्य रूप x xसे अप्रयुक्त लैम्ब्डा कैलकुलस में स्व-अनुप्रयोग को व्यक्त करता है। और यह वाई कोम्बिनेटर के रूप में परिभाषित करने की अनुमति देता है λf.(λx.f(xx))(λx.f(xx))।

---

अपडेट: जैसा कि सुझाव दिया गया है, मैं एक ऐसा संस्करण पोस्ट कर रहा हूं, जो अप्रकाशित लैम्ब्डा कैलकुलस में Y की परिभाषा के करीब है:

data Strange a = C (Strange a -> a)

-- | Apply one term to another, removing the constructor.
(#) :: Strange a -> Strange a -> a
(C f) # x = f x
infixl 3 #

-- The Y combinator, which allows to express arbitrary recursion
yc :: (a -> a) -> a
yc f =  C (\x -> f (x # x)) # C (\x -> f (x # x))

main = yc (putStrLn "Hello world" >>)

Comments

पुनरावर्ती कार्यों के बजाय पुनरावर्ती डेटा संरचनाएं ... अच्छा।

— अप्रोचडार्कनेसफिश

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

— जेक

आप letबाध्यकारी को हटा सकते हैं और परिभाषित कर सकते हैं yc f = extract $ C $ f.extract, क्योंकि letयकीनन एक ऐसी भाषा सुविधा है जो पुनरावर्तन (शास्त्रीय let x = x in x) की अनुमति देती है । यह कुछ वर्णों को भी कम करता है :)

— पृथ्वी इंजन

या यहां तक ​​किyc = extract . C . (.extract)

— पृथ्वी इंजन

@EarthEngine सच है, मैं सिर्फ संरचना को मूल परिभाषा के करीब रखना चाहता था Y।

— पेट्र पुडल्क

Answer 12

सी ++

निम्नलिखित 10 से एक उलटी गिनती आउटपुट "ब्लास्ट ऑफ!" टेम्पलेट मेटाप्रोग्रामिंग का उपयोग करना।

#include <iostream>

template<int N>
void countdown() {
    std::cout << "T minus " << N << std::endl;
    countdown<N-1>();
}

template<>
void countdown<0>() {
    std::cout << "Blast off!" << std::endl;
}

int main()
{
    countdown<10>();
    return 0;
}

यह पुनरावृत्ति के एक क्लासिक उदाहरण की तरह लग सकता है, लेकिन यह वास्तव में आपकी परिभाषा के आधार पर, कम से कम तकनीकी रूप से नहीं है। कंपाइलर दस अलग-अलग फ़ंक्शन उत्पन्न करेगा । countdown<10>प्रिंट "टी माइनस 10" और फिर कॉल countdown<9>, और इतने पर नीचे countdown<0>, जो प्रिंट "ब्लास्ट ऑफ!" और फिर लौटता है। जब आप कोड संकलित करते हैं तो पुनरावृत्ति होती है, लेकिन निष्पादन योग्य में कोई लूपिंग संरचना नहीं होती है।

C ++ 11 में कोई भी constexprकीवर्ड का उपयोग करके समान प्रभाव प्राप्त कर सकता है , जैसे कि यह तथ्यात्मक कार्य। (यह उलटी गिनती उदाहरण को लागू करना संभव नहीं है, क्योंकि constexprकार्यों के दुष्प्रभाव नहीं हो सकते हैं, लेकिन मुझे लगता है कि यह आगामी सी ++ 14 में संभव हो सकता है।)

constexpr int factorial(int n)
{
    return n <= 1 ? 1 : (n * factorial(n-1));
}

फिर यह वास्तव में प्रत्यावर्तन की तरह दिखता है, लेकिन संकलक बाहर का विस्तार होगा factorial(10)में 10*9*8*7*6*5*4*3*2*1, और उसके बाद शायद की एक निरंतर मूल्य के साथ बदलना 3628800है, तो निष्पादन किसी भी पाशन या पुनरावर्ती कोड शामिल नहीं होंगे।

Comments

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

— लेउशेंको

@Leushenko हाँ मुझे पता है। लेकिन तब फिर से टेम्पलेट उदाहरण उदाहरण एक ही बात करता है - संकलन-समय पर ट्यूरिंग-पूर्ण भाषा में एक पुनरावर्ती फ़ंक्शन का उपयोग करता है - केवल अंतर यह है कि कॉन्स्टैक्स एक ऐसी भाषा का उपयोग करता है जो C ++ की तरह बहुत अधिक दिखता है। जैसा कि सभी उत्तरों के साथ यह नियमों को झुकाता है, और मैं इसके बारे में ईमानदार हूं। constexprखासतौर पर (कुछ पहलुओं के) खाके को मेट्रोपोग्रामिंग अप्रचलित बनाने के लिए बनाया गया था, इसलिए यह निश्चित रूप से इस विषय पर एक पोस्ट में उल्लेख के लायक है।

— नथानिएल

+1: &countdown<N-1> != &countdown<N>।

— थॉमस ईडिंग

Answer 13

जावा

चलो जावा वर्ग लोडर के साथ खेलते हैं और इसे अपने माता-पिता के रूप में सेट करते हैं:

import java.lang.reflect.Field;

public class Loop {
    public static void main(String[] args) throws Exception {
        System.out.println("Let's loop");
        Field field = ClassLoader.class.getDeclaredField("parent");
        field.setAccessible(true);
        field.set(Loop.class.getClassLoader(), Loop.class.getClassLoader());

    }
}

यह लूप वास्तव में इतना मजबूत है कि आपको kill -9इसे रोकने के लिए उपयोग करना होगा :-)

यह मेरे मैक के सीपीयू का 100,1% उपयोग करता है।

आप System.outवैकल्पिक मजेदार व्यवहार का प्रयोग करने के लिए मुख्य कार्य के अंत में स्थानांतरित करने का प्रयास कर सकते हैं।

Comments

जबरदस्त हंसी। जावा अपने आप में अटक जाना :)

— मास्टरएक्स 244

JVM पुनरावर्ती लोडिंग हैक से प्यार करें।

— इशीया मीडोज

Answer 14

सी तेज

एक और समान रूप से दुष्ट ::

public class P{

    class A<B>{
        public static int C<T>(){
            System.Console.WriteLine(typeof(T));
            return C<A<T>>();
        }
    }
    public static void Main(){
        A<P>.C<int>();
    }
}

यह पुनरावृत्ति नहीं है ... यह कोड टेम्प्लेट का पुनरीक्षण है। जबकि ऐसा प्रतीत होता है कि हम उसी विधि को कॉल कर रहे हैं, रनटाइम लगातार नए तरीके बना रहा है। हम int के प्रकार के पैरामीटर का उपयोग करते हैं, क्योंकि यह वास्तव में इसे एक नया प्रकार बनाने के लिए मजबूर करता है और विधि के प्रत्येक उदाहरण को एक नई विधि से जुड़ना पड़ता है। यह यहाँ साझा नहीं कर सकता। आखिरकार, हम कॉल स्टैक को मारते हैं क्योंकि यह हमारे द्वारा वादा किए गए इंट की वापसी के लिए असीम रूप से इंतजार करता है लेकिन कभी भी वितरित नहीं किया जाता है। इसी तरह से, हम इसे दिलचस्प बनाए रखने के लिए हमारे द्वारा बनाए गए प्रकार को लिखते रहते हैं। मूल रूप से प्रत्येक C जिसे हम कहते हैं, एक ऊर्जावान नई विधि है जिसमें बस एक ही शरीर है। यह वास्तव में C ++ या D जैसी भाषा में संभव नहीं है जो संकलन समय पर अपने टेम्पलेट करते हैं। चूंकि, C # JIT सुपर आलसी है, यह केवल अंतिम संभव क्षण में इस सामान को बनाता है। इस प्रकार,

Answer 15

Redcode 94 (कोर वार)

MOV 0, 1

एक पते पर शून्य पते पर निर्देश की प्रतिलिपि। क्योंकि कोर वॉर में सभी पते वर्तमान पीसी पते के सापेक्ष होते हैं और कोर के आकार को मापते हैं, यह एक अनंत लूप है, नॉन-जंप, इंस्ट्रक्शन।

इस कार्यक्रम (योद्धा) को " छोटा सा भूत " कहा जाता है और पहली बार एके डेवडनी द्वारा प्रकाशित किया गया था।

Comments

Imps मार्च करेंगे, अपने गेट तैयार करेंगे, उन्हें तैयार करेंगे या आपको कुचल दिया जाएगा।

— seequ

अपने SPL 0, 0; MOV 1, -2वास्तव में तैयार है।

— 21

अच्छा, मैं उम्मीद कर रहा था कि यह अभी तक पोस्ट नहीं किया गया है। +1

— mbomb007 19

Answer 16

तीव्र गति

मुझे लगता है कि यह किसी भी वास्तविक पुनरावर्ती कार्य के बिना पुनरावृत्ति करने का शास्त्रीय तरीका होगा। नीचे कोई भी कार्य सीधे या परोक्ष रूप से नाम से संदर्भित नहीं होता है।

(इसे dartpad.dartlang.org पर देखें )

// Strict fixpoint operator.
fix(f) => ((x)=>f(x(x))) ((x)=>(v)=>f(x(x))(v));
// Repeat action while it returns true.
void repeat(action) { fix((rep1) => (b) { if (b()) rep1(b); })(action); }

main() {
  int x = 0;
  repeat(() {  
    print(++x);
    return x < 10;
  });
}

Comments

वाई कॉम्बिनेटर?

— 17

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

— lrn

Answer 17

जे एस

बहुत मूल नहीं बल्कि छोटा। 20 चरस।

setInterval(alert,1)

Comments

आप वास्तव में निकाल सकते हैं ,1और यह अभी भी काम करेगा,

— डेरेक 會

@ डेरेक 會 朕 ere अगर मैं ऐसा करता हूं, तो मुझे फ़ायरफ़ॉक्स पर केवल एक ही अलर्ट मिलता है

— xem

क्रोम में यह अंतिम पैरामीटर के बिना काम करता है। यदि यह कम से कम एक वातावरण में काम करता है तो कोड को मान्य माना जाना चाहिए।

— डेरेक 會 會

@ डेरेक 會 會 功夫setIntervalएक बयान नहीं है, हालांकि; यह केवल एक फ़ंक्शन है। इसका उपयोग अभिव्यक्ति कथन के अंदर किया जाता है, और यदि हम अभिव्यक्ति कथनों का उपयोग नहीं कर सकते हैं, तो मैं अभी और भी नहीं जानता।

— कीन

@Cory - वैसे मुझे लगता है कि तब मान्य है!

— डेरेक 會 朕 k

Answer 18

सी में सिग्नल

#include <stdio.h>
#include <signal.h>

int main(void) {
    signal(SIGSEGV, main);
    *(int*)printf("Hello, world!\n") = 0;
    return 0;
}

इस कार्यक्रम का व्यवहार स्पष्ट रूप से बहुत अपरिभाषित है, लेकिन आज, मेरे कंप्यूटर पर, यह "हैलो, दुनिया!" छापता रहता है।

Answer 19

Emacs लिस्प

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

मैक्रोज़ जनरेट कोड जो माना हुआ लूप का अनियंत्रित संस्करण है और जो उत्पन्न कोड है वह रनटाइम पर मूल्यांकन किया जाता है।

इसे दोहराएं: आपको एन बार लूप करने की अनुमति देता है

(defmacro repeat-it (n &rest body)
  "Evaluate BODY N number of times.
Returns the result of the last evaluation of the last expression in BODY."
  (declare (indent defun))
  (cons 'progn (make-list n (cons 'progn body))))

इसे दोहराएं:

;; repeat-it test
(progn
  (setq foobar 1)

  (repeat-it 10
    (setq foobar (1+ foobar)))

  ;; assert that we incremented foobar n times
  (assert (= foobar 11)))

दोहराने यह साथ-सूचकांक:

यह मैक्रो जैसा है repeat-itलेकिन यह वास्तव में आम लूपिंग मैक्रो की तरह ही काम करता है do-timesयह आपको एक प्रतीक निर्दिष्ट करने की अनुमति देता है जो लूप इंडेक्स के लिए बाध्य होगा। यह यह सुनिश्चित करने के लिए कि यह परिवर्तन लूप बॉडी के दौरान मान है या नहीं, प्रत्येक लूप की शुरुआत में इंडेक्स वेरिएबल को सही ढंग से सेट किया गया है, यह विस्तार करने के लिए एक एक्सपेंशन टाइम सिंबल का उपयोग करता है।

(defmacro repeat-it-with-index (var-and-n &rest body)
  "Evaluate BODY N number of times with VAR bound to successive integers from 0 inclusive to n exclusive..
VAR-AND-N should be in the form (VAR N).
Returns the result of the last evaluation of the last expression in BODY."
  (declare (indent defun))
  (let ((fallback-sym (make-symbol "fallback")))
    `(let ((,(first var-and-n) 0)
           (,fallback-sym 0))
       ,(cons 'progn
              (make-list (second var-and-n)
                         `(progn
                            (setq ,(first var-and-n) ,fallback-sym)
                            ,@body
                            (incf ,fallback-sym)))))))

दोहराएँ-साथ-सूचकांक परीक्षण:

इस परीक्षण से पता चलता है कि:

1. शरीर N समय का मूल्यांकन करता है

2. सूचकांक चर हमेशा प्रत्येक पुनरावृत्ति की शुरुआत में सही ढंग से सेट किया जाता है

3. "फ़ॉलबैक" नाम के प्रतीक के मूल्य को बदलना सूचकांक में गड़बड़ नहीं करेगा

;; repeat-it-with-index test
(progn
  ;; first expected index is 0
  (setq expected-index 0)

  ;; start repeating
  (repeat-it-with-index (index 50)
    ;; change the value of a  'fallback' symbol
    (setq fallback (random 10000))
    ;; assert that index is set correctly, and that the changes to
    ;; fallback has no affect on its value
    (assert (= index expected-index))
    ;; change the value of index
    (setq index (+ 100 (random 1000)))
    ;; assert that it has changed
    (assert (not (= index expected-index)))
    ;; increment the expected value
    (incf expected-index))

  ;; assert that the final expected value is n
  (assert (= expected-index 50)))

Answer 20

अनपम लमबा पथरी

λf.(λx.f (x x)) (λx.f (x x))

Comments

मुझे यकीन नहीं है कि अगर यह रिकर्सन के रूप में गिना जाता है या नहीं, तो इसके लिए मौलिक सैद्धांतिक आधार क्या है ... वैसे भी +1।

— शराबी

@fluffy यह स्वयं पुनरावर्ती नहीं है, कोई भी फ़ंक्शन स्वयं को कॉल नहीं करता है (विशेषकर क्योंकि फ़ंक्शन का नाम नहीं है)।

— गर्वित हैकेलर 16

IMHO, लैम्ब्डा कैलकुलस गणना का एक मॉडल है और यह एक प्रोग्रामिंग भाषा नहीं है (यानी एक ठोस मशीन मॉडल के बिना, हम लंबो कैलकुलस को PL के रूप में नहीं मान सकते हैं)।

— ता

आप पूरी तरह से एक मशीन का निर्माण कर सकते हैं जो लैम्ब्डा कैलकुलस की व्याख्या करता है। और सिंटैक्स का उपयोग प्रोग्रामिंग भाषा के रूप में किया जा सकता है। उदाहरण के लिए देखें github.com/MaiaVictor/caramel

— आर्थर बी

Answer 21

हास्केल, 24 वर्ण

sequence_ (repeat (print "abc"))

या एक संघनित रूप में, 24 अक्षरों के साथ

sequence_$repeat$print"" 

(हालांकि पाठ को बदल दिया गया है, यह अभी भी लूप करेगा - यह दो उद्धरण और एक नई पंक्ति को असीम रूप से प्रिंट करेगा)

स्पष्टीकरण: प्रिंट "एबीसी" मूल रूप से एक i / o क्रिया है जो सिर्फ "एबीसी" प्रिंट करता है।
दोहराना एक फ़ंक्शन है जो एक मान x लेता है और केवल x से बना एक अनंत सूची देता है।
अनुक्रम_ एक फ़ंक्शन है जो i / o क्रियाओं की एक सूची लेता है और एक i / o क्रिया देता है जो सभी क्रियाओं को क्रमिक रूप से करता है।

इसलिए, मूल रूप से, यह कार्यक्रम प्रिंट "एबीसी" कमांड की एक अनंत सूची बनाता है, और बार-बार उन्हें निष्पादित करता है। कोई छोरों या पुनरावृत्ति के साथ।

Comments

मैं मूल रूप से क्लोजर में एक ही उत्तर पोस्ट करने जा रहा था, लेकिन मुझे लगा कि repeatहोगा a programming language statement which allows code to be repeatedly executed।

— १६

fix(print"">>), इसमें पुनरावृत्ति कार्यों का स्पष्ट रूप से नाम भी शामिल नहीं है।

— मानीप

@ मुझे पता नहीं है कि क्लोजर में कैसा है, लेकिन हास्केल रिपीट में "एक प्रोग्रामिंग भाषा स्टेटमेंट नहीं है जो कोड को बार-बार निष्पादित करने की अनुमति देता है" - यह एक ऐसा फ़ंक्शन है जो अनंत सूचियां बनाता है। यह एक लूप है जैसा कि "int [] arr = {x, x, x};" एक पाश है।

— गर्वित हैकेलर

हाँ, लेकिन कुछ को पुनरावृत्ति का उपयोग करके कार्यान्वित किया जाना चाहिए, क्योंकि इसके बिना मूल रूप से असंभव है

— गर्व हैकर

वास्तव में, इस कोड में होने वाले प्रत्येक कार्य को पुनरावृत्ति का उपयोग करके परिभाषित किया जाता है - यहां तक ​​कि प्रिंट

— गर्वित हेकलर

Answer 22

ASM (x86 + I / O लिनक्स के लिए)

इससे कोई फर्क नहीं पड़ता कि आपकी उच्च स्तरीय भाषाओं में कितना संघर्ष होगा, यह अभी भी सिर्फ छिपा हुआ निर्देश सूचक हेरफेर होगा। अंत में, यह "गोटो" (जेएमपी) का कुछ प्रकार होगा, जब तक कि आप रनटाइम में लूप को अनियंत्रित करने के लिए पर्याप्त ऊब नहीं होते।

आप Ideone पर कोड का परीक्षण कर सकते हैं

आप मैटियो इटालिया डॉस कोड में इस विचार के अधिक परिष्कृत संस्करण की जांच कर सकते हैं ।

यह 0..9 के स्ट्रिंग के साथ शुरू होता है और इसे ए..जे के साथ बदल देता है, कोई प्रत्यक्ष कूदता नहीं है (इसलिए कहता है कि कोई "गोटो" नहीं हुआ), कोई पुनरावृत्ति भी नहीं।

कोड शायद पता गणना के कुछ दुरुपयोग के साथ छोटा हो सकता है, लेकिन ऑनलाइन संकलक पर काम करना परेशान है इसलिए मैं इसे छोड़ दूंगा जैसा कि यह है।

मुख्य भाग:

mov dl, 'A' ; I refuse to explain this line!
mov ebx, msg ; output array (string)

call rawr   ; lets put address of "rawr" line on stack
rawr: pop eax ; and to variable with it! In same time we are breaking "ret"

add eax, 4 ; pop eax takes 4 bytes of memory, so for sake of stack lets skip it
mov [ebx], dl ; write letter
inc dl ; and proceed to next 
inc ebx
cmp dl, 'J' ; if we are done, simulate return/break by leaving this dangerous area
jg print

push eax ; and now lets abuse "ret" by making "call" by hand
ret

पूरा कोड

section     .text
global      _start                              

_start:

;<core>
mov dl, 'A'
mov ebx, msg

call rawr
rawr: pop eax

add eax, 4
mov [ebx], dl
inc dl
inc ebx
cmp dl, 'J'
jg print

push eax
ret
;</core>

; just some Console.Write()
print:
    mov     edx,len
    mov     ecx,msg
    mov     ebx,1
    mov     eax,4
    int     0x80

    mov     eax,1
    xor     ebx, ebx
    int     0x80

section     .data

msg     db  '0123456789',0xa
len     equ $ - msg

Comments

मैं इसे codegolf.stackexchange.com/a/34298/11259 की संख्या के रूप में कॉल करने जा रहा था , लेकिन मुझे लगता है कि यह पहले वाला उत्तर है। +1

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

@DigitalTrauma ओह, मुझे लगता है कि किसी ने मेरे विचार का परिष्कृत संस्करण बनाया है - पुरानी चाल, लेकिन प्रबंधित कोड के युग में लोग भूल गए कि चीजें वास्तव में कैसे काम करती हैं। (मुझे गोल्फ पसंद नहीं है, वैसे भी अक्सर "माँ को देखना कम हो जाता है! मैं एक कुंजी दबाकर सामान बना सकता हूं!")

— PTwr

Answer 23

C प्रीप्रोसेसर

एक छोटी सी "तकनीक" जिसे मैं एक चुनौती चुनौती के दौरान लेकर आया था। कोई फ़ंक्शन पुनरावर्तन नहीं है, लेकिन वहाँ है ... फ़ाइल पुनरावर्तन?

noloop.c:

#if __INCLUDE_LEVEL__ == 0
int main() 
{
    puts("There is no loop...");
#endif
#if __INCLUDE_LEVEL__ <= 16
    puts(".. but Im in ur loop!");
    #include "noloop.c"
#else
    return 0;
}
#endif

मैंने gcc का उपयोग करके इसे लिखा / परखा। स्पष्ट रूप से आपके कंपाइलर को संकलन करने के लिए __INCLUDE_LEVEL__मैक्रो (या वैकल्पिक रूप से __COUNTER__कुछ ट्विकिंग के साथ मैक्रो) का समर्थन करने की आवश्यकता है । यह काफी स्पष्ट होना चाहिए कि यह कैसे काम करता है, लेकिन मज़े के लिए, कोड को संकलित किए बिना प्रीप्रोसेसर को चलाएं ( -Eजीसीएल के साथ ध्वज का उपयोग करें )।

Answer 24

पीएचपी

यहाँ PHP के साथ एक है। काउंटर तक $ अधिकतम पहुंचने तक एक ही फ़ाइल शामिल करके लूप्स:

<?php
if (!isset($i))
    $i = 0;        // Initialize $i with 0
$max = 10;         // Target value

// Loop body here
echo "Iteration $i <br>\n";

$i++;               // Increase $i by one on every iteration

if ($i == $max)
    die('done');    // When $i reaches $max, end the script
include(__FILE__);  // Proceed with the loop
?>

फॉर-लूप के समान:

<?php
for ($i = 0; $i < 10; $i++) {
    echo "Iteration $i <br>\n";
}
die('done');
?>

Comments

डार, यह रिकर्सन के रूप में भी गिना जाता है, है ना?

— पिचन

ऐसा मत सोचो - यह समानता @ नाथनियल के उदाहरण के रूप में याद आती है: प्रीप्रोसेसर में ये फाइलें शामिल होंगी, जिनका मूल्यांकन एक साथ किया जाता है।

— eithed

@Pichan मैं कहूंगा कि यह लूप अनफॉलोिंग का अधिक है, क्योंकि आप मेमोरी में कोड की प्रतियों के साथ समाप्त होते हैं।

— पीटीओआर

मैंने आज केवल प्रश्न देखा और लगभग समान कोड के साथ आया। मेरे लिए बहुत देर हो गई!

— TecBrat

क्या header("Location: .?x=".$_GET['x']+1);रिकर्सन के रूप में गिना जाता है?

— चार्ली

Answer 25

अजगर

निम्नलिखित कोड शामिल नहीं पुनरावर्ती क्रिया (प्रत्यक्ष या अप्रत्यक्ष रूप से), कोई आदिम पाशन और किसी भी अंतर्निहित फ़ंक्शन को कॉल नहीं करता है (सिवाय print):

def z(f):
    g = lambda x: lambda w: f(lambda v: (x(x))(v), w)
    return g(g)

if __name__ == "__main__":
    def msg(rec, n):
        if (n > 0):
            print "Hello world!"
            rec(n - 1)
    z(msg)(7)

प्रिंट "नमस्ते दुनिया!" दिए गए समय की संख्या।

स्पष्टीकरण: फ़ंक्शन सख्त Z निश्चित-बिंदु कॉम्बिनेटर कोz लागू करता है , जो (जबकि पुनरावर्ती रूप से परिभाषित नहीं) किसी भी पुनरावर्ती एल्गोरिथ्म को व्यक्त करने की अनुमति देता है।

Comments

मैं gबहुत ही अप्रत्यक्ष रूप से पुनरावर्ती कहूंगा ।

— बजे

@ क्यों क्यों? आपका तर्क क्या है? क्या करता है gकॉल कि कॉल gफिर से? बेशक यह चाल आत्म-अनुप्रयोग है g(g), लेकिन इसमें कोई पुनरावृत्ति शामिल नहीं है। gयदि आपने नहीं देखा है तो क्या आप वास्तव में अप्रत्यक्ष रूप से पुनरावर्ती कहेंगे g(g)? यह मानक तरीका है कि इसे भाषाओं में कैसे किया जाए जो पुनरावर्ती परिभाषाओं की अनुमति नहीं देता है, जैसे कि लैम्ब्डा कैलकुलस।

— पेट्र पुडलक

आप gतर्क के रूप में देते हैं xऔर फिर कॉल करते हैं x(x)।

— Seequ

@ TheRare एक फ़ंक्शन (या फ़ंक्शन का एक सेट) इसका उपयोग कैसे किया जाता है, इसके द्वारा पुनरावर्ती या गैर-पुनरावर्ती नहीं है, यह सिर्फ इसकी परिभाषा से निर्धारित होता है।

— पेट्र पुडलक

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

— वेन कॉनराड

Answer 26

z80 मशीन कोड

ऐसे वातावरण में जहाँ आप हर पते और नक्शे पर हर जगह निष्पादित कर सकते हैं, 64kb का मानचित्र पूरे पता स्थान पर शून्य से भरा हुआ है।

यह क्या करता है: कुछ भी नहीं। बार-बार।

यह कैसे काम करता है: प्रोसेसर निष्पादित करना शुरू कर देगा, बाइट 00एक nopनिर्देश है, इसलिए यह बस चालू रहेगा, पते पर पहुंच जाएगा $ffff, चारों ओर $0000लपेटेगा और nopतब तक निष्पादित करना जारी रखेगा जब तक आप इसे रीसेट नहीं करते।

इसे थोड़ा और दिलचस्प बनाने के लिए, स्मृति को कुछ अन्य मूल्य से भरें (नियंत्रण प्रवाह निर्देशों से बचने के लिए सावधान रहें)।

Comments

आप मेमोरी को शून्य से भर सकते हैं, और वहां कहीं वास्तविक कार्यक्रम रख सकते हैं।

— देखिए

तो आप 64k कार्यक्रम में डाल सकते हैं, जिसमें कोई शाखा नहीं है, और यह सिर्फ बार-बार निष्पादित होगा?

— बिल वुडगर

@BillWoodger आप कर सकते हैं, खासकर अगर आपके पास मंच पर कोई व्यवधान नहीं है (या कोई भी सक्षम नहीं है)

— हेरोल्ड

मस्ती की तरह :-)

— बिल वुडर

Answer 27

पर्ल-regex

(q x x x 10) =~ /(?{ print "hello\n" })(?!)/;

डेमो

या इसे इस प्रकार आज़माएँ:

perl -e '(q x x x 10) =~ /(?{ print "hello\n" })(?!)/;'

(?!)कभी भी मेल नहीं। तो रेगेक्स इंजन मिलान किए गए स्ट्रिंग में प्रत्येक शून्य चौड़ाई के पदों से मेल खाने की कोशिश करता है ।

यह (q x x x 10)उसी तरह है (" " x 10)- spaceदस बार दोहराएं ।

संपादित करें: बेहतर समझ के लिए अधिक सटीक होने के लिए "वर्ण" को शून्य चौड़ाई के पदों में बदल दिया । इस स्टैकओवरफ़्लो प्रश्न के उत्तर देखें ।

Answer 28

टी-एसक्यूएल -12

print 1
GO 9

वास्तव में Sql सर्वर प्रबंधन स्टूडियो के एक quirk के अधिक। GO एक स्क्रिप्ट सेपरेटर है और T-SQL भाषा का हिस्सा नहीं है। यदि आप GO को एक संख्या द्वारा निर्दिष्ट करते हैं तो यह कई बार ब्लॉक को निष्पादित करेगा।

Comments

मैं लगभग हर रोज टी-एसक्यूएल का उपयोग करता हूं और मुझे पता नहीं था कि आप जीओ के साथ ऐसा कर सकते हैं। +1

— सेलिनप जुले

तकनीकी रूप से, यह T-SQL नहीं है। GOवास्तव में एक SSMS निर्देश है, यही वजह है कि आप इसे टी-एसक्यूएल स्क्रिप्टेड ऑब्जेक्ट्स में नहीं रख सकते हैं, जैसे कि एक संग्रहीत कार्यविधि।

— RBarryYoung

हाँ, मैंने अपने स्पॉइलर टिप्पणी में जोड़ा है। मुझे लगता है कि sqlcmd का उपयोग करना बहुत अधिक धोखा होगा।

— माइकल बी

Answer 29

सी#

Uint.MaxValue से 0 तक सभी पूर्णांक प्रिंट करता है।

   class Program
   {
      public static void Main()
      {
          uint max = uint.MaxValue;
          SuperWriteLine(ref max);
          Console.WriteLine(0);
      }

      static void SuperWriteLine(ref uint num)
      {
          if ((num & (1 << 31)) > 0) { WriteLine32(ref num); }
          if ((num & (1 << 30)) > 0) { WriteLine31(ref num); }
          if ((num & (1 << 29)) > 0) { WriteLine30(ref num); }
          if ((num & (1 << 28)) > 0) { WriteLine29(ref num); }
          if ((num & (1 << 27)) > 0) { WriteLine28(ref num); }
          if ((num & (1 << 26)) > 0) { WriteLine27(ref num); }
          if ((num & (1 << 25)) > 0) { WriteLine26(ref num); }
          if ((num & (1 << 24)) > 0) { WriteLine25(ref num); }
          if ((num & (1 << 23)) > 0) { WriteLine24(ref num); }
          if ((num & (1 << 22)) > 0) { WriteLine23(ref num); }
          if ((num & (1 << 21)) > 0) { WriteLine22(ref num); }
          if ((num & (1 << 20)) > 0) { WriteLine21(ref num); }
          if ((num & (1 << 19)) > 0) { WriteLine20(ref num); }
          if ((num & (1 << 18)) > 0) { WriteLine19(ref num); }
          if ((num & (1 << 17)) > 0) { WriteLine18(ref num); }
          if ((num & (1 << 16)) > 0) { WriteLine17(ref num); }
          if ((num & (1 << 15)) > 0) { WriteLine16(ref num); }
          if ((num & (1 << 14)) > 0) { WriteLine15(ref num); }
          if ((num & (1 << 13)) > 0) { WriteLine14(ref num); }
          if ((num & (1 << 12)) > 0) { WriteLine13(ref num); }
          if ((num & (1 << 11)) > 0) { WriteLine12(ref num); }
          if ((num & (1 << 10)) > 0) { WriteLine11(ref num); }
          if ((num & (1 << 9)) > 0) { WriteLine10(ref num); }
          if ((num & (1 << 8)) > 0) { WriteLine09(ref num); }
          if ((num & (1 << 7)) > 0) { WriteLine08(ref num); }
          if ((num & (1 << 6)) > 0) { WriteLine07(ref num); }
          if ((num & (1 << 5)) > 0) { WriteLine06(ref num); }
          if ((num & (1 << 4)) > 0) { WriteLine05(ref num); }
          if ((num & (1 << 3)) > 0) { WriteLine04(ref num); }
          if ((num & (1 << 2)) > 0) { WriteLine03(ref num); }
          if ((num & (1 <<  1)) > 0) { WriteLine02(ref num); }
          if ((num & (1 <<  0)) > 0) { WriteLine01(ref num); }
      }

      private static void WriteLine32(ref uint num) { WriteLine31(ref num); WriteLine31(ref num); }
      private static void WriteLine31(ref uint num) { WriteLine30(ref num); WriteLine30(ref num); }
      private static void WriteLine30(ref uint num) { WriteLine29(ref num); WriteLine29(ref num); }
      private static void WriteLine29(ref uint num) { WriteLine28(ref num); WriteLine28(ref num); }
      private static void WriteLine28(ref uint num) { WriteLine27(ref num); WriteLine27(ref num); }
      private static void WriteLine27(ref uint num) { WriteLine26(ref num); WriteLine26(ref num); }
      private static void WriteLine26(ref uint num) { WriteLine25(ref num); WriteLine25(ref num); }
      private static void WriteLine25(ref uint num) { WriteLine24(ref num); WriteLine24(ref num); }
      private static void WriteLine24(ref uint num) { WriteLine23(ref num); WriteLine23(ref num); }
      private static void WriteLine23(ref uint num) { WriteLine22(ref num); WriteLine22(ref num); }
      private static void WriteLine22(ref uint num) { WriteLine21(ref num); WriteLine21(ref num); }
      private static void WriteLine21(ref uint num) { WriteLine20(ref num); WriteLine20(ref num); }
      private static void WriteLine20(ref uint num) { WriteLine19(ref num); WriteLine19(ref num); }
      private static void WriteLine19(ref uint num) { WriteLine18(ref num); WriteLine18(ref num); }
      private static void WriteLine18(ref uint num) { WriteLine17(ref num); WriteLine17(ref num); }
      private static void WriteLine17(ref uint num) { WriteLine16(ref num); WriteLine16(ref num); }
      private static void WriteLine16(ref uint num) { WriteLine15(ref num); WriteLine15(ref num); }
      private static void WriteLine15(ref uint num) { WriteLine14(ref num); WriteLine14(ref num); }
      private static void WriteLine14(ref uint num) { WriteLine13(ref num); WriteLine13(ref num); }
      private static void WriteLine13(ref uint num) { WriteLine12(ref num); WriteLine12(ref num); }
      private static void WriteLine12(ref uint num) { WriteLine11(ref num); WriteLine11(ref num); }
      private static void WriteLine11(ref uint num) { WriteLine10(ref num); WriteLine10(ref num); }
      private static void WriteLine10(ref uint num) { WriteLine09(ref num); WriteLine09(ref num); }
      private static void WriteLine09(ref uint num) { WriteLine08(ref num); WriteLine08(ref num); }
      private static void WriteLine08(ref uint num) { WriteLine07(ref num); WriteLine07(ref num); }
      private static void WriteLine07(ref uint num) { WriteLine06(ref num); WriteLine06(ref num); }
      private static void WriteLine06(ref uint num) { WriteLine05(ref num); WriteLine05(ref num); }
      private static void WriteLine05(ref uint num) { WriteLine04(ref num); WriteLine04(ref num); }
      private static void WriteLine04(ref uint num) { WriteLine03(ref num); WriteLine03(ref num); }
      private static void WriteLine03(ref uint num) { WriteLine02(ref num); WriteLine02(ref num); }
      private static void WriteLine02(ref uint num) { WriteLine01(ref num); WriteLine01(ref num); }
      private static void WriteLine01(ref uint num) { Console.WriteLine(num--); }
   }

Comments

मैं वास्तव में नहीं जानता कि क्या यह मायने रखता है। आप स्पष्ट रूप से WriteLine01 Int.MaxValue बार कॉल कर रहे हैं। यह बस कॉलस्टैक की एक बड़ी मात्रा के पीछे विस्फोट हो गया।

— माइकल बी

इसकी गिनती कैसे नहीं होती? कोई लूप नहीं है और कोई पुनरावृत्ति नहीं है।

— LVBen

इसके अलावा, कॉल स्टैक कहीं भी बड़े पैमाने पर नहीं है जब तक कि आप 32 कॉल को बड़े पैमाने पर नहीं मानते।

— LVBen

4294967296 बार के बजाय केवल 32 बार ही क्यों?

— LVBen

@ ja72 अगर मैं कभी किसी ओपन सोर्स प्रोजेक्ट पर काम कर रहा हूं जिसमें मैं लूप या रिकर्सन का उपयोग नहीं कर सकता हूं, तो मैं पूरी तरह से इस तरह कोड का योगदान करने जा रहा हूं!

— LVBen

Answer 30

JS (ब्राउज़र में)

इस बारे में कैसा है?

document.write(new Date());
location = location;

वर्तमान समय प्रिंट करता है और पृष्ठ को फिर से लोड करता है।

Comments

ओह, मारो। मैंने बस उसी मूल अवधारणा के साथ उत्तर पोस्ट किया है। मैं "जावास्क्रिप्ट" या HTML टैग दिखाने वाली किसी चीज़ के लिए पृष्ठ को स्कैन कर रहा था। मुझे लगता है कि मैं अपना जवाब छोड़ सकता हूं, सिर्फ इसलिए कि यह कोने-केस को संभालता है जहां स्थान में "#" होता है। वैसे भी, +1।

— कीन

फ़ायरफ़ॉक्स 30 में:[Exception... "The operation is insecure." code: "18" nsresult: "0x80530012 (SecurityError)" location: "<unknown>"]

— एलेक्स रेनॉल्ड्स

@AlexReynolds हुह, अजीब। मेरा एफएफ 30 पर ठीक काम करता है।

— पचन

जैसा कि लिखा गया था, मैंने केवल आपके कोड को कॉपी और पेस्ट किया है। यह काम नहीं करता है। शायद आपके पास कुछ विशेष सुरक्षा प्राथमिकताएं हैं जो इस काम को करने में सक्षम हैं?

— एलेक्स रेनॉल्ड्स

@AlexReynolds नहीं, कभी भी कोई सुरक्षा सेटिंग नहीं बदली। और यह क्रोम पर भी काम करता है।

— पिचान