फैक्टरियल, फाइबोनैचि संख्याओं के बिना पुनरावृत्ति

Question

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

1. गणित
2. असल जिंदगी में बेकार

क्या कुछ दिलचस्प गैर-गणित कोड उदाहरण हैं जो पुनरावृत्ति सिखाने के लिए हैं?

मैं एल्गोरिदम को विभाजित करने और जीतने के लिए सोच रहा हूं लेकिन वे आमतौर पर जटिल डेटा संरचनाओं को शामिल करते हैं।

Comments

जबकि आपका प्रश्न पूरी तरह से मान्य है, मैं वास्तविक जीवन में फाइबोनैचि संख्याओं को बेकार कहने में संकोच करूंगा । एक ही तथ्य के लिए चला जाता है ।

— ज़च एल

द लिटिल सीमर रिकर्सन पर एक पूरी किताब है जो कभी भी फैक्ट या फिब का उपयोग नहीं करता है। junix-linux-config.googlecode.com/files/…

— एरिक विल्सन

@Zach: तब भी, जब तेजी से चल रहे समय के कारण रिबोरेंस फिबोनाची संख्या को लागू करने का एक भयानक तरीका है ।

— dan04

@ dan04: अधिकांश लानागो में स्टैक ओवरफ्लो की संभावना के कारण लगभग कुछ भी लागू करने के लिए पुनरावृत्ति एक भयानक तरीका है।

— आर ..

@ dan04 जब तक आपकी भाषा सबसे कार्यात्मक भाषाओं की तरह पूंछ कॉल अनुकूलन को लागू करने के लिए पर्याप्त स्मार्ट नहीं है, जिस स्थिति में यह ठीक काम करता है

— Zachary K

Answer 1

निर्देशिका / फ़ाइल संरचनाएं पुनरावृत्ति के लिए उपयोग का सबसे अच्छा उदाहरण हैं, क्योंकि हर कोई आपको शुरू करने से पहले उन्हें समझता है, लेकिन पेड़ जैसी संरचनाओं से जुड़े कुछ भी करेंगे।

void GetAllFilePaths(Directory dir, List<string> paths)
{
    foreach(File file in dir.Files)
    {
        paths.Add(file.Path);
    }

    foreach(Directory subdir in dir.Directories)
    {
        GetAllFilePaths(subdir, paths)
    }
}

List<string> GetAllFilePaths(Directory dir)
{
    List<string> paths = new List<string>();
    GetAllFilePaths(dir, paths);
    return paths;
}

Comments

धन्यवाद, मुझे लगता है कि मैं फाइलसिस्टम के साथ जाऊंगा। यह कुछ ठोस है और इसका उपयोग कई वास्तविक दुनिया के उदाहरणों के लिए किया जा सकता है।

— सिनैप

नोट: यूनिक्स कमांड अक्सर -r विकल्प (उदाहरण के लिए सीपी या आरएम) को हटा दें। पुनरावर्ती के लिए खड़े हो जाओ।

— deadalnix

यहां आपको थोड़ा सावधान रहना होगा क्योंकि वास्तविक विश्व फ़ाइल सिस्टम वास्तव में एक निर्देशित ग्राफ़ हैं जो आवश्यक रूप से एक पेड़ नहीं हैं, यदि फ़ाइल सिस्टम द्वारा समर्थित है, तो हार्ड लिंक आदि से जोड़ और चक्र

— jk

@jk: निर्देशिकाएँ कड़ी से कड़ी नहीं हो सकती हैं, इसलिए कुछ पत्तियों को मोडुलो किया जा सकता है जो एक से अधिक स्थानों पर दिखाई दे सकती हैं, और यह मानते हुए कि आप सहानुभूति को छोड़ देते हैं, वास्तविक विश्व फाइल सिस्टम पेड़ हैं।

— आर ..

कुछ फ़ाइल सिस्टम में निर्देशिकाओं के लिए अन्य ख़ासियतें हैं जैसे कि NTFS पुन: अंक। मेरा कहना है कि कोड है कि विशेष रूप से इस बारे में पता नहीं है वास्तविक दुनिया फ़ाइल सिस्टम पर अप्रत्याशित परिणाम हो सकते हैं

— जे.के.

Answer 2

उन चीजों की तलाश करें जिनमें पेड़ की संरचनाएं शामिल हैं। एक पेड़ को पकड़ना अपेक्षाकृत आसान होता है, और एक पुनरावर्ती समाधान की सुंदरता रैखिक डेटा संरचनाओं जैसे सूचियों की तुलना में जल्द ही स्पष्ट हो जाती है।

सोचने वाली बातें:

• filesystems - वे मूल रूप से पेड़ हैं; एक अच्छा प्रोग्रामिंग कार्य एक निश्चित निर्देशिका और उसके सभी उपनिर्देशिकाओं के तहत सभी .jpg छवियों को लाने के लिए होगा
• पूर्वज - एक परिवार का पेड़ दिया गया, एक सामान्य पूर्वज को खोजने के लिए आपको कितनी पीढ़ियों को चलना होगा; या जाँच करें कि क्या पेड़ में दो लोग एक ही पीढ़ी के हैं; या जाँच करें कि क्या पेड़ में दो लोग कानूनी रूप से शादी कर सकते हैं (अधिकार क्षेत्र पर निर्भर करता है :)
• एचटीएमएल-जैसे दस्तावेज़ - एक दस्तावेज़ और एक डोम ट्री के धारावाहिक (पाठ) प्रतिनिधित्व के बीच परिवर्तित; एक डोम के सबसेट पर संचालन करें (शायद xpath का सबसेट भी लागू करें?); ...

ये सभी वास्तविक वास्तविक दुनिया के परिदृश्यों से संबंधित हैं, और इन सभी का उपयोग वास्तविक-विश्व महत्व के अनुप्रयोगों में किया जा सकता है।

Comments

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

— आर ..

पॉइंटर्स का इससे क्या लेना-देना है? यहां तक ​​कि जब आपके पास पहले बच्चे, अगले भाई और माता-पिता के लिए संकेत होते हैं, तब भी आपको किसी तरह अपने पेड़ से चलना पड़ता है, और कुछ मामलों में, पुनरावृत्ति सबसे संभव तरीका है।

— tdammers

Answer 3

https://stackoverflow.com/questions/105838/real-world-examples-of-recursion

• एक संक्रामक संक्रमण मॉडलिंग
• ज्यामिति उत्पन्न करना
• निर्देशिका प्रबंधन
• छंटाई

https://stackoverflow.com/questions/2085834/how-did-you-practically-use-recursion

• किरण पर करीबी नजर रखना
• शतरंज
• पार्सिंग सोर्स कोड (भाषा व्याकरण)

https://stackoverflow.com/questions/4945128/what-is-a-good-example-of-recursion-other-than-generating-a-fibonacci-sequence

• BST खोज
• हनोई के टावर
• palindrome खोज

https://stackoverflow.com/questions/126756/examples-of-recursive-functions

• एक अच्छी अंग्रेजी-कहानी देता है जो एक सोने की कहानी द्वारा पुनरावृत्ति दिखाता है।

Comments

जबकि यह सैद्धांतिक रूप से प्रश्न का उत्तर दे सकता है, उन प्रश्नों और उत्तरों के आवश्यक भागों को यहां शामिल करना बेहतर होगा , और संदर्भ के लिए लिंक प्रदान करना। यदि प्रश्न कभी SO से हटाए जाते हैं, तो आपका उत्तर पूरी तरह से बेकार हो जाएगा।

— एडम लेअर

@ अन्ना खैर, उपयोगकर्ता अपने प्रश्नों को हटा नहीं सकते हैं इसलिए ऐसा होने की कितनी संभावना है?

— vemv

@vemv वोट, मॉडरेटर्स को हटाएं, विषय बदलने के बारे में नियम ... यह हो सकता है। किसी भी तरह से, यहाँ एक और अधिक पूर्ण उत्तर होने के कारण बल्ले से चार अलग-अलग पृष्ठों पर आगंतुक भेजने से बेहतर होगा।

— एडम लेअर

@ एना: सोच की इस लाइन के बाद, "सटीक डुप्लिकेट" के रूप में बंद किए गए प्रत्येक प्रश्न का उत्तर मूल चिपकाया गया होना चाहिए। यह प्रश्न एक सटीक डुप्लिकेट है (एसओ पर प्रश्नों का), इसे सटीक से भिन्न उपचार क्यों मिलना चाहिए। प्रोग्रामर पर सवालों की नकल?

— एसएफ।

@ एसएफ यदि हम इसे डुप्लिकेट के रूप में बंद कर सकते हैं, तो हम करेंगे, लेकिन क्रॉस-साइट डुप्लिकेट समर्थित नहीं हैं। प्रोग्रामर एक अलग साइट है, इसलिए आदर्श रूप से यहां के उत्तर किसी भी अन्य संदर्भ के रूप में एसओ का उपयोग करेंगे, न कि इसे पूरी तरह से प्रतिनिधि। तकनीकी रूप से सत्य होने पर - "आपका उत्तर इस पुस्तक में है" कहने से यह अलग नहीं है, लेकिन संदर्भ के परामर्श के बिना इसका तुरंत उपयोग नहीं किया जा सकता।

— एडम लेअर

Answer 4

यहाँ कुछ और व्यावहारिक समस्याएं हैं जो मेरे दिमाग में आती हैं:

• मर्ज़ सॉर्ट
• द्विआधारी खोज
• ट्रैवर्सल, प्रविष्टि और पेड़ों पर हटाने (बड़े पैमाने पर डेटाबेस अनुप्रयोगों पर उपयोग किया जाता है)
• क्रमपरिवर्तन जनरेटर
• सुडोकू सॉल्वर (बैकट्रैकिंग के साथ)
• वर्तनी-जाँच (फिर से पीछे की ओर)
• सिंटैक्स विश्लेषण (.eg, एक प्रोग्राम जो उपसर्ग को पोस्टफिक्स नोटेशन में परिवर्तित करता है)

Answer 5

क्विकसॉर्ट पहला ऐसा होगा जो मन को कूदता है। बाइनरी खोज भी एक पुनरावर्ती समस्या है। इससे परे कि समस्याओं के पूरे वर्ग हैं जो समाधान लगभग मुफ्त में गिरते हैं जब आप पुनरावृत्ति के साथ काम करना शुरू करते हैं।

Comments

द्विआधारी खोज को अक्सर एक पुनरावर्ती समस्या के रूप में तैयार किया जाता है लेकिन यह अनिवार्य तरीके से लागू करने के लिए तुच्छ (और अक्सर बेहतर) है।

— शराबी

इस पर निर्भर करता है कि आप कोड का उपयोग किस भाषा में कर रहे हैं या स्पष्ट रूप से पुनरावर्ती या अनिवार्य या पुनरावर्ती नहीं हो सकते हैं। लेकिन यह अभी भी एक पुनरावर्ती एल्गोरिथ्म है कि आप समस्या को हल करने के लिए छोटे और छोटे विखंडू में तोड़ रहे हैं।

— ज़ाचरी के

@Zachary: एल्गोरिथ्म जिन्हें पूंछ पुनर्संरचना (जैसे बाइनरी खोज) के साथ लागू किया जा सकता है , उन लोगों की तुलना में एक मौलिक रूप से अलग अंतरिक्ष वर्ग में होते हैं जिन्हें वास्तविक पुनरावर्तन (या समान रूप से महंगी अंतरिक्ष आवश्यकताओं के साथ आपके स्वयं के राज्य ढांचे) की आवश्यकता होती है। मुझे नहीं लगता कि यह उनके लिए एक साथ सिखाया जा सकता है जैसे कि वे समान हैं।

— आर ..

Answer 6

क्रमबद्ध, पायथन में पुनरावर्ती रूप से परिभाषित।

def sort( a ):
    if len(a) == 1: return a
    part1= sort( a[:len(a)//2] )
    part2= sort( a[len(a)//2:] )
    return merge( part1, part2 )

विलय, पुनरावर्ती रूप से परिभाषित।

def merge( a, b ):
    if len(b) == 0: return a
    if len(a) == 0: return b
    if a[0] < b[0]:
        return [ a[0] ] + merge(a[1:], b)
    else:
        return [ b[0] ] + merge(a, b[1:]) 

रैखिक खोज, पुनरावर्ती रूप से परिभाषित।

def find( element, sequence ):
    if len(sequence) == 0: return False
    if element == sequence[0]: return True
    return find( element, sequence[1:] )

बाइनरी खोज, पुनरावर्ती रूप से परिभाषित।

def binsearch( element, sequence ):
    if len(sequence) == 0: return False
    mid = len(sequence)//2
    if element < mid: 
        return binsearch( element, sequence[:mid] )
    else:
        return binsearch( element, sequence[mid:] )

Answer 7

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

कुछ उदाहरणों में पुनरावृत्ति सिखाने के लिए गणित शामिल नहीं है (कम से कम उन समस्याओं को जो मुझे अपने विश्वविद्यालय के वर्षों से याद हैं):

• हनोई के टावर
• आठ रानियाँ

ये समस्या को हल करने के लिए Backtracking का उपयोग करने के उदाहरण हैं।

अन्य समस्याएं आर्टिफिशियल इंटेलिजेंस डोमेन की क्लासिक्स हैं: गहराई का पहला खोज, पाथफाइंडिंग, योजना का उपयोग करना।

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

0 = खाली सूची 1 = एक नोड के साथ सूची। 2 = 2 नोड्स के साथ सूची। ...

फिर इस डेटा संरचना के संदर्भ में दो संख्याओं के योग को इस तरह परिभाषित करें: खाली + एन = एन नोड (एक्स) + एन = नोड (एक्स + एन)

Answer 8

हनोई की टावर्स पुनरावृत्ति सीखने में मदद करने के लिए एक अच्छा एक है।

कई अलग-अलग भाषाओं में वेब पर इसके कई समाधान हैं।

Comments

यह वास्तव में मेरी राय में एक और बुरा उदाहरण है। सबसे पहले, यह अवास्तविक है; यह वास्तव में लोगों के लिए एक समस्या नहीं है। दूसरा, आसान गैर-पुनरावर्ती समाधान हैं। (एक है: संख्या डिस्क। कभी भी एक ही समता की एक डिस्क पर एक डिस्क को स्थानांतरित न करें और आपके द्वारा किए गए अंतिम कदम को कभी भी पूर्ववत न करें। यदि आप उन दो नियमों का पालन करते हैं, तो आप पहेली को इष्टतम समाधान से हल करेंगे। किसी भी पुनरावृत्ति की आवश्यकता नहीं है। )

— एरिक Lippert

Answer 9

एक Palindrome डिटेक्टर:

एक स्ट्रिंग के साथ शुरू करें: "ABCDEEDCBA" यदि आरंभ और समाप्ति वर्ण समान हैं, तो "BCDEEDCB", आदि की पुनरावृत्ति और जांच करें ...

Comments

यह भी पुनरावृत्ति के बिना हल करने के लिए तुच्छ है, और IMHO, इसके बिना बेहतर हल।

— ब्लरफुल

सहमत थे, लेकिन ओपी ने विशेष रूप से डेटा संरचनाओं के न्यूनतम उपयोग के साथ शिक्षण उदाहरणों के लिए कहा।

— NWS

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

— मोनिका

Answer 10

एक द्विआधारी खोज एल्गोरिथ्म लगता है कि आप क्या चाहते हैं।

Answer 11

कार्यात्मक प्रोग्रामिंग भाषाओं में, जब कोई उच्च-क्रम के कार्य उपलब्ध नहीं होते हैं, तो पारस्परिक स्थिति से बचने के लिए पुनरावर्ती का उपयोग अनिवार्य छोरों के बजाय किया जाता है।

एफ # एक अशुद्ध कार्यात्मक भाषा है जो दोनों शैलियों की अनुमति देती है इसलिए मैं यहां दोनों की तुलना करूंगा। निम्नलिखित एक सूची में सभी संख्याओं को जोड़ते हैं।

म्यूटेबल वैरिएबल के साथ इंपीरियल लूप

let xlist = [1;2;3;4;5;6;7;8;9;10]
let mutable sum = 0
for x in xlist do
    sum <- sum + x

पुनरावर्ती लूप बिना म्यूटेबल स्टेट के साथ

let xlist = [1;2;3;4;5;6;7;8;9;10]
let rec loop sum xlist = 
    match xlist with
    | [] -> sum
    | x::xlist -> loop (sum + x) xlist
let sum = loop 0 xlist

ध्यान दें कि एकत्रीकरण के इस प्रकार है उच्च आदेश समारोह में कब्जा List.foldऔर के रूप में लिखा जा सकता है List.fold (+) 0 xlistया वास्तव में और भी अधिक साधारणत: सुविधा के समारोह के साथ List.sumबस के रूप में List.sum xlist।

Comments

आप मुझ से सिर्फ +1 से अधिक अंक के हकदार होंगे। एफ # बिना पुनरावृत्ति बहुत थकाऊ होगा, यह हास्केल के लिए और भी अधिक सच है जिसमें कोई लूपिंग निर्माण नहीं है केवल पुनरावृत्ति!

— schoetbi

Answer 12

मैंने AI खेलने वाले गेम में रिकर्सन का जमकर इस्तेमाल किया है। C ++ में लिखना, मैंने लगभग 7 फ़ंक्शन की एक श्रृंखला का उपयोग किया है जो एक दूसरे को कॉल करते हैं (पहले फ़ंक्शन के साथ उन सभी को बायपास करने का विकल्प होता है और 2 और फ़ंक्शंस की श्रृंखला के बजाय कॉल करते हैं)। या तो श्रृंखला में अंतिम फ़ंक्शन ने पहले फ़ंक्शन को फिर से बुलाया, जब तक कि शेष गहराई मैं खोजना चाहता था 0 पर चला गया, उस स्थिति में अंतिम फ़ंक्शन मेरे मूल्यांकन फ़ंक्शन को कॉल करेगा और स्थिति के स्कोर को वापस कर देगा।

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

आप इस तरह के कार्यक्रम की एक बहुत ही बुनियादी रूपरेखा देख सकते हैं, https://secure.wikimedia.org/wikipedia/en/wiki/Minimax#Pseudocode देखें

Answer 13

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

अब BOM के बारे में किसी भी समग्र जानकारी को क्वेरी करने के लिए या BOM में तत्वों को बदलने के लिए अक्सर आप पुनरावृत्ति का सहारा लेते हैं।

    class BomPart
    {
        public string PartNumber { get; set; }
        public string Desription { get; set; }
        public int Quantity { get; set; }
        public bool Plastic { get; set; }
        public List<BomPart> Components = new List<BomPart>();
    }

और एक नमूना पुनरावर्ती कॉल ...

    static int ComponentCount(BomPart part)
    {
        int subCount = 0;
        foreach(BomPart p in part.Components)
            subCount += ComponentCount(p);
        return part.Quantity * Math.Max(1,subCount);

    }

जाहिर है कि बॉमपार्ट क्लास में कई और क्षेत्र होंगे। आपको यह पता लगाने की आवश्यकता हो सकती है कि आपके पास कितने प्लास्टिक घटक हैं, एक पूर्ण भाग के निर्माण में कितना श्रम लगता है, आदि। यह सब एक पेड़ की संरचना पर पुनरावृत्ति की उपयोगिता पर वापस आता है।

Comments

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

— इयान

Answer 14

पारिवारिक संबंध अच्छे उदाहरणों के लिए बनाते हैं क्योंकि हर कोई उन्हें सहज रूप से समझता है:

ancestor(joe, me) = (joe == me) 
                    OR ancestor(joe, me.father) 
                    OR ancestor(joe, me.mother);

Comments

यह कोड किस भाषा में लिखा गया है?

— törzsmókus 4

@ törzsmókus कोई विशिष्ट भाषा नहीं। सिंटैक्स C, Obj-C, C ++, Java, और कई अन्य भाषाओं के बहुत करीब है, लेकिन यदि आप वास्तविक कोड चाहते हैं तो आपको एक उपयुक्त ऑपरेटर जैसे कि के ||लिए विकल्प की आवश्यकता हो सकती है OR।

— कालेब

Answer 15

बल्कि बेकार है फिर भी पुनरावृत्ति दिखा आंतरिक काम अच्छी तरह से पुनरावर्ती है strlen():

size_t strlen( const char* str )
{
    if( *str == 0 ) {
       return 0;
    }
    return 1 + strlen( str + 1 );
}

कोई गणित नहीं - एक बहुत ही सरल कार्य। बेशक आप इसे वास्तविक जीवन में पुनरावर्ती रूप से लागू नहीं करते हैं, लेकिन यह पुनरावृत्ति का एक अच्छा डेमो है।

Answer 16

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

Comments

पारंपरिक अर्थों में पुनरावृत्ति के विरोध में प्रक्रिया कतार द्वारा आम तौर पर बेहतर कार्य किया जाता है।

— शराबी

Answer 17

मैंने एक पुनरावर्ती कार्यक्रम का उपयोग करके एक नाइट पैटर्न (शतरंज की बिसात पर) के साथ एक समस्या को हल किया। आप शूरवीर को चारों ओर ले जाने वाले थे ताकि यह कुछ चिह्नित वर्गों को छोड़कर हर वर्ग को छू सके।

आप बस:

mark your "Current" square
gather a list of free squares that are valid moves
are there no valid moves?
    are all squares marked?
        you win!
for each free square
    recurse!
clear the mark on your current square.
return.    

कई तरह के "थिंक-फॉरवर्ड" परिदृश्यों को इस तरह से एक पेड़ में भविष्य की संभावनाओं का परीक्षण करके काम किया जा सकता है।