दिलचस्प पोस्ट
Intellij IDEA 12 (और 13) में Google-Play- सेवाओं को आयात करना .NET में NameValueCollection में किसी क्वेरी स्ट्रिंग को कैसे विश्लेषित करें IOS – MKMapView स्थान का उपयोग करके अक्षांश / लंबे स्थान के बजाय ऐपेशन समकक्ष प्रणाली में एक चरित्र को कैसे परिवर्तित करें। Windows.Input.Key Enum मान? सत्र अपहरण को रोकना System.Net.WebRequest का उपयोग करते समय कुछ HTTP हेडर सेट नहीं कर सकते चयन 2 लटकती लेकिन उपयोगकर्ता द्वारा नए मानों की अनुमति है? पिक्सेल में स्क्रीन आयाम प्राप्त करें प्रतिलिपि निर्माता बनाम क्लोन () HAVING और WHERE में अंतर क्या है? वीबीए का इस्तेमाल करते हुए टीएक्सटी फाइल बनाने और लिखना बिटमैप को बिटमैप सोर्स WPF में तेजी से परिवर्तित करना पायथन में एक नियमित प्रारूप में तिथि कैसे मुद्रित करें? सुरक्षा नियमों में सीमित फायरबेज दर? WPF WebBrowser नियंत्रण – स्क्रिप्ट त्रुटियों को दबाने के लिए कैसे?

हनोई के टॉवर: पुनरावर्ती अल्गोरिदम

यद्यपि मुझे कोई समस्या जो पुनरावृत्ति को समझने में नहीं है, मुझे हनोई की समस्या के टॉवर के पुनरावर्ती समाधान के चारों ओर मेरे सिर को लपेटने में प्रतीत नहीं हो सकता। यहां विकिपीडिया से कोड है:

procedure Hanoi(n: integer; source, dest, by: char); Begin if (n=1) then writeln('Move the plate from ', source, ' to ', dest) else begin Hanoi(n-1, source, by, dest); writeln('Move the plate from ', source, ' to ', dest); Hanoi(n-1, by, dest, source); end; End; 

मैं बेस केस और समस्या को छोटे टुकड़ों में तोड़ने की अवधारणा को समझता हूं जब तक आप एक डिस्क को स्थानांतरित करने में सक्षम नहीं हो जाते। हालांकि, मैं यह नहीं समझ सकता कि गैर-बेस केस में दो पुनरावर्ती कॉल एक साथ काम करते हैं। शायद कोई मेरी मदद कर सकता है? धन्यवाद।

वेब के समाधान से एकत्रित समाधान "हनोई के टॉवर: पुनरावर्ती अल्गोरिदम"

दरअसल, जिस अनुभाग से आपने यह कोड लिया था, वह भी स्पष्टीकरण प्रदान करता है:

एन डिस्क्स को खूंटी ए से खूंटी को ले जाने के लिए:

  1. ए से बी को एन -1 डिस्क ले जाएं। यह अकेले पेग ए पर डिस्क # डालता है
  2. डिस्क से डिस्क # को ले जाएं सी से
  3. एन से 1 डिस्क को बी से सी में ले जाएं ताकि वे डिस्क # पर बैठ सकें

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

आपकी पोस्ट में कोड के तीन तर्क हैं, डिस्क की संख्या के अलावा: एक स्रोत खूंटी, एक गंतव्य कपाट और एक अस्थायी खूंटी जिसके बीच डिस्क को बीच में संग्रहीत किया जा सकता है (जहां प्रत्येक डिस्क को आकार n – 1 फिट बैठता है)।

रिकर्सन वास्तव में दो बार होता है, वहां, एक बार लेख के पहले, एक बार बाद। writeln से पहले writeln को अस्थायी खूंटी पर n – 1 डिस्क्स को स्थानांतरित किया जाएगा, जो गंतव्य खूंटी का उपयोग अस्थायी भंडार के रूप में होगा (पुनरावर्ती कॉल में तर्क भिन्न क्रम में हैं)। उसके बाद शेष डिस्क को गंतव्य खूंटी में स्थानांतरित कर दिया जाएगा और बाद में दूसरे पुनर्कलन के लिए पूरे टॉवर की गति बढ़ जाती है, जो नॉन-टॉवर को अस्थायी खूंटी से गंतव्य खूंटी तक ले जाया जाता है, डिस्क से ऊपर

एक साल पहले मेरे पास कार्यात्मक प्रोग्रामिंग कोर्स था और एल्गोरिथम के लिए इस दृष्टांत को आकर्षित किया था। आशा करता हूँ की ये काम करेगा!

 (0) _|_ | | __|__ | | ___|___ | | ____|____ ____|____ ____|____ (1.1) | | | __|__ | | ___|___ _|_ | ____|____ ____|____ ____|____ (A -> B) (1.2) | | | | | | ___|___ _|_ __|__ ____|____ ____|____ ____|____ (A -> C) (1.3) | | | | | _|_ ___|___ | __|__ ____|____ ____|____ ____|____ (B -> C) (2.1) | | | | | _|_ | ___|___ __|__ ____|____ ____|____ ____|____ (A -> B) (3.1) | | | | | | _|_ ___|___ __|__ ____|____ ____|____ ____|____ (C -> A) (3.2) | | | | __|__ | _|_ ___|___ | ____|____ ____|____ ____|____ (C -> B) (3.3) | _|_ | | __|__ | | ___|___ | ____|____ ____|____ ____|____ (A -> B) 

3 छल्ले की समस्या 2 2-छल्ले की समस्या (1.x और 3.x) में विभाजित की गई है

http://www.cs.cmu.edu/~cburch/survey/recurse/hanoiimpl.html पर पुनरावर्ती हनोई कार्यान्वयन का एक अच्छा विवरण है।

सारांश यह है कि यदि आप नीचे की प्लेट को छड़ी करने के लिए ए को छड़ीना चाहते हैं, तो आपको पहले से सी के ऊपर सभी छोटे प्लेटें ऊपर लेनी पड़ेगी। दूसरा पुनरावर्ती कॉल तब प्लेट्स को स्थानांतरित करने के लिए है जिसे आप सी में ले गए आपके बेस केस के बाद बी पर वापस ए से बी की एक बड़ी प्लेट ले जाया गया।

मैं इससे सहमत हूं कि जब आप इसे पहली बार देखते हैं, तो तत्काल नहीं होता है, लेकिन जब आप इसे नीचे उतरते हैं तो यह काफी आसान है।

बेस केस: आपका टावर आकार 1 का है। तो आप इसे एक कदम से सीधे स्रोत से डिस्ल्ट तक कर सकते हैं।

पुनरावर्ती मामले: आपका टावर आकार का है> 1>। तो आप आकार के शीर्ष टॉवर को एन -1 से एक अतिरिक्त खूंटी (द्वारा) तक ले जाएं, आकार 1 के नीचे "टॉवर" को गंतव्य खूंटी पर ले जाएं और शीर्ष टॉवर को स्थानांतरित करें द्वारा डिस्ट से

तो एक सरल मामला के साथ, आपके पास ऊंचाई 2 का एक टावर है:

  _|_ | | __|__ | | ===== ===== ===== 

पहला चरण: 2-1 (= 1) के शीर्ष टॉवर को अतिरिक्त खूंटी पर ले जाएं (बीच एक, कह देता है)।

  | | | __|__ _|_ | ===== ===== ===== 

अगला: नीचे डिस्क को गंतव्य पर ले जाएं:

  | | | | _|_ __|__ ===== ===== ===== 

और अंत में, गंतव्य के शीर्ष (2-1) = 1 के शीर्ष टॉवर को स्थानांतरित करें।

  | | _|_ | | __|__ ===== ===== ===== 

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

मान लीजिए हम ए से सी के माध्यम से एक डिस्क को स्थानांतरित करना चाहते हैं तो:

  1. बी के लिए एक छोटी डिस्क ले जाएं
  2. दूसरे डिस्क को सी में ले जाएँ
  3. बी से सी ले जाएं
  4. ए से बी ले जाएं
  5. सभी को सी से ए में ले जाएं

यदि आप सभी उपरोक्त चरणों को दोहराते हैं, तो डिस्क स्थानांतरित हो जाएगी।

मुझे दर्द महसूस होता है!

यद्यपि यह एक पुरानी पोस्ट है, मुझे लगता है कि वास्तव में समझने की क्या जरूरत है, यह "इस पर" इस ​​दृष्टिकोण को नहीं ले जाता है, लेकिन जवाब में पुनरावर्तन के पक्ष-प्रभाव का उपयोग करना शामिल है

मेरे लिए एक अनमोल मदद "द लिटिल स्कीमर" थी, जो एक को पुनरावृत्त कार्यों को सोचने और लिखने के लिए सिखाती है।

हालांकि, यह पाठक को अगले पुनरावर्ती कॉल में दिए गए परिणामों के परिणाम का उपयोग करने के लिए सिखाता है।

हनोई के टॉवर में, जवाब परिणामस्वरूप प्रतिफल में नहीं है, लेकिन लौट आए परिणाम के अवलोकन में।

फ़ंक्शन पैरामीटर की सफलतापूर्वक पुनर्व्यवस्था में जादू होती है।

हां समस्या वास्तव में तीन भागों में है:

  • अतिरिक्त खूंटी के लिए एक छोटे से टॉवर चलाना
  • गंतव्य कंधे पर आखिरी डिस्क को ले जाना
  • शेष टावर को खुली खूंटी पर गंतव्य खूंटी पर ले जाया जा रहा है।

योजना में

 (define (th nabc) (if (zero? n) 'done (begin (th (- n 1) acb) (display (list ac)) (newline) (th (- n 1) bac)))) (th 5 'source 'spare 'destination) 

हालांकि यह फ़ंक्शन मापदंडों का प्रदर्शन है जो समस्या का समाधान है और कॉल की संरचना जैसे दुलहन पेड़ को समझने के लिए महत्वपूर्ण है।

समाधान भी proof by induction की शक्ति और सभी प्रोग्रामर, जो परंपरागत नियंत्रण संरचनाओं से मल्लयुद्ध करते हैं, को गर्म चमक बताते हैं।

संयोग से, हाथ से समस्या को हल करने के लिए काफी संतोषजनक है।

  • डिस्क की संख्या की गणना करें
  • अगर भी, पहली डिस्क को अतिरिक्त खूंटी में ले जाएं, तो आगे कानूनी चालें (शीर्ष डिस्क को शामिल न करें) करें फिर शीर्ष डिस्क को गंतव्य कंकड़ में ले जाएं, आगे की कानूनी कार्रवाई करें (एनआईटीडी)। फिर शीर्ष डिस्क को स्रोत पेग पर ले जाएं, आगे की कानूनी कार्रवाई करें (निट्ड) …
  • यदि अजीब, पहली डिस्क को गंतव्य कंकड़ में ले जाएं, तो अगले कानूनी कदम (शीर्ष डिस्क को शामिल न करें) बनाएं फिर शीर्ष डिस्क को अतिरिक्त खूंटी पर ले जाएं, आगे की कानूनी चालें (एनआईटीडी) करें। फिर शीर्ष डिस्क को स्रोत पेग पर ले जाएं, आगे की कानूनी कार्रवाई करें (निट्ड) …

हमेशा सबसे अच्छा एक ही हाथ से शीर्ष डिस्क धारण करके और हमेशा उस दिशा में एक ही दिशा में चल रहा है।

n डिस्क्स के लिए चाल की अंतिम संख्या 2^n - 1 move n disc to destination लिए move n disc to destination प्रक्रिया के माध्यम से आधी है।

अंत में, यह मज़ेदार है कि किसी सहकर्मी, आपकी पत्नी / पति या यहां तक ​​कि कुत्ते (यहां तक ​​कि वे जो सुन नहीं रहे हैं) को समस्या समझा रहे हैं , ज्ञान को सीमेंट कर सकते हैं।

इन सब स्पष्टीकरणों को पढ़ने के बाद मैंने सोचा कि मैं हनोई रिकर्सिव समाधान के टावर्स को समझाने के लिए इस्तेमाल किया मेरे प्रोफेसर विधि के साथ तौलना होगा। यह फिर से एल्गोरिथ्म है जो एन के छल्ले की संख्या का प्रतिनिधित्व करता है, और ए, बी, सी खूंटे का प्रतिनिधित्व करते हैं। फ़ंक्शन का पहला पैरामीटर रिंगों की संख्या है, दूसरा पैरामीटर स्रोत कपाट का प्रतिनिधित्व करता है, तीसरा गंतव्य खूंटी है, और चौथा अतिरिक्त खूंटी है।

 procedure Hanoi(n, A, B, C); if n == 1 move ring n from peg A to peg B else Hanoi(n-1, A, C, B); move ring n-1 from A to C Hanoi(n-1, C, B, A); end; 

मुझे स्नातक विद्यालय में पढ़ाया जाता था ताकि कभी भी छोटे से सोचने में मुझे शर्म न लगे। तो, चलो n = 5 के लिए इस एल्गोरिथ्म पर गौर करें। खुद को पूछने का सवाल यह है कि क्या मैं 5 से अंगूठी को ए से बी में ले जाना चाहता हूं, अन्य 4 अंगूठियां कहां हैं? अगर 5 वीं अंगूठी खूंटी ए पर रहती है और हम इसे खूंटी बी में ले जाना चाहते हैं, तो दूसरे 4 रिंग केवल कपाट सी पर ही हो सकते हैं। फ़ंक्शन हनोई (एन -1, ए, सी, बी) के ऊपर एल्गोरिथ्म में उन सभी 4 अन्य अंगूठे को खूंटी सी पर ले जाएं, तो अंगूठी 5 ए से आगे बढ़ने में सक्षम हो जाएगी। इस एल्गोरिथम के बाद हम n = 4 को देखते हैं। यदि अंगूठी 4 को ए से सी में ले जाया जाएगा, जहां छल्ले हैं 3 और छोटे? वे केवल खूंटी बी पर हो सकते हैं। अगला, n = 3 के लिए, यदि अंगूठी 3 को ए से बी में ले जाया जाएगा, जहां 2 और 1 छल्ले हैं? खैर सी कोर्स पर यदि आप इस पद्धति का पालन करते रहेंगे तो आप कल्पना कर सकते हैं कि पुनरावर्ती एल्गोरिथ्म क्या कर रहा है। यह दृष्टिकोण नौसिखिया के दृष्टिकोण से अलग है जिसमें यह पिछले डिस्क को पहली बार दिखता है और पहली डिस्क पिछले है।

इसे डिस्क के व्यास के साथ स्टैक के रूप में सोचकर पूर्णांक (4,3,2,1) द्वारा प्रस्तुत किया जाता है, पहले पुनर्कलन कॉल को 3 गुणा कहा जाएगा और इस प्रकार रन-टाइम स्टैक को इस प्रकार से भरना होगा

  1. पहला कॉल: 1. दूसरा कॉल: 2,1 और तीसरा कॉल: 3,2,1

पहले पुनरावर्ती समाप्त होने के बाद, रन-टाइम स्टैक की सामग्री को मध्य ध्रुव में सबसे बड़ा व्यास से छोटा (सबसे पहले पिछला) में खड़ा किया जाता है। इसके बाद, डिस्क 4 व्यास के साथ गंतव्य स्थानांतरित हो जाती है।

दूसरा पुनरावर्ती कॉल, मध्य ध्रुव से गंतव्य तक के स्थान पर जाने के अपवाद के साथ पहले के समान है।

यह आसान है। मान लीजिए आप ए से सी में स्थानांतरित करना चाहते हैं

अगर केवल एक डिस्क है, तो उसे स्थानांतरित करें

यदि एक से अधिक डिस्क है, तो करें

  • सभी डिस्क (एन -1 डिस्क) को स्थानांतरित करने के लिए, नीचे एक को ए से बी को छोड़कर
  • नीचे से डिस्क को ए से सी में ले जाएं
  • ए से सी के पहले चरण से n-1 डिस्क को स्थानांतरित करें

ध्यान रखें कि, जब n-1 डिस्क को स्थानांतरित करते हैं, तो nth बिल्कुल भी एक समस्या नहीं होगी (एक बार यह अन्य सभी की तुलना में बड़ा है)

ध्यान दें कि एन -1 डिस्क को स्थानांतरित करने से एक ही समस्या पर पुन: पुनरावर्ती हो जाती है, n-1 = 1 तक, उस स्थिति में आप पहले पर होंगे (जहां आपको उसे स्थानांतरित करना चाहिए)।

प्रश्न के उत्तर में, प्रोग्राम कैसे पता चलता है, कि "aux" के लिए "src" भी है, और ओपन है "src" को "डीएसटी" खोलने के लिए कार्यक्रम में है। यदि आप 4 डिस्क के साथ मुट्ठी को तोड़ते हैं, तो यह इस तरह दिखता है:

 hanoi(4, "src", "aux", "dst"); if (disc > 0) { hanoi(3, 'src', 'dst', 'aux'); if (disc > 0) { hanoi(2, 'src', 'aux', 'dst'); if (disc > 0) { hanoi(1, 'src', 'dst', 'aux'); if (disc > 0) { hanoi(0, 'src', 'aux', 'dst'); END document.writeln("Move disc" + 1 + "from" + Src + "to" + Aux); hanoi(0, 'aux', 'src', 'dst'); END } 

यह भी 4 डिस्क (यहां तक ​​कि) के साथ पहला कदम Src से Aux तक जाता है।

जैसा कि हमारे कुछ दोस्तों ने सुझाव दिया है, मैंने पिछले दो उत्तर हटा दिए हैं और मैं यहां मजबूत करता हूं।

यह आपको स्पष्ट समझ देता है

सामान्य एल्गोरिथ्म क्या है ….

कलन विधि:

 solve(n,s,i,d) //solve n discs from s to d, s-source i-intermediate d-destination { if(n==0)return; solve(n-1,s,d,i); // solve n-1 discs from s to i Note:recursive call, not just move move from s to d; // after moving n-1 discs from s to d, a left disc in s is moved to d solve(n-1,i,s,d); // we have left n-1 disc in 'i', so bringing it to from i to d (recursive call) } 

यहां काम करने का उदाहरण यहां क्लिक करें

 public static void hanoi(int number, String source, String aux, String dest) { if (number == 1) { System.out.println(source + " - > "+dest); } else{ hanoi(number -1, source, dest, aux); hanoi(1, source, aux, dest); hanoi(number -1, aux, source, dest); } } 
 void TOH(int n, int a, int b){ /*Assuming a as source stack numbered as 1, b as spare stack numbered as 2 and c as target stack numbered as 3. So once we know values of a and b, we can determine c as there sum is a constant number (3+2+1=)6. */ int c = 6-ab; if(n==1){ cout<<"Move from "<<a<<" to "<<b<<"\n"; } else{ // Move n-1 disks from 1st to 2nd stack. As we are not allowed to move more than one disks at a time, we do it by recursion. Breaking the problem into a simpler problem. TOH(n-1, a, c); // Move the last alone disk from 1st to 3rd stack. TOH(1, a, b); // Put n-1 disks from 2nd to 3rd stack. As we are not allowed to move more than one disks at a time, we do it by recursion. Breaking the problem into a simpler problem. TOH(n-1, c, b); } } int main() { TOH(2, 1, 3); cout<<"FINISHED \n"; TOH(3, 1, 3); cout<<"FINISHED \n"; TOH(4, 1, 3); return 0; } 

तीन टावर हैं, अर्थात् स्रोत टॉवर, गंतव्य टॉवर और सहायक टॉवर। स्रोत टावर में सभी डिस्क हैं और आपका लक्ष्य सभी डिस्क को गंतव्य टॉवर पर ले जाने और ऐसा करने में सुनिश्चित करने के लिए है, आप कभी भी छोटी डिस्क के ऊपर एक बड़ी डिस्क नहीं डालते हैं हम निम्न चरणों में पुनर्रचना का उपयोग करते हुए इस समस्या को हल कर सकते हैं:

स्रोत टावर पर हमारे पास कई डिस्क नंबर हैं

बेस केस: n = 1 यदि स्रोत टावर में केवल एक डिस्क है, तो इसे गंतव्य टॉवर पर ले जाएं।

रिकर्सिव केस: n> 1

  • स्रोत टावर से सहायक टॉवर तक की शीर्ष एन -1 डिस्क को स्थानांतरित करें
  • गंतव्य टॉवर पर केवल शेष, nth डिस्क (चरण 1 के बाद) को स्थानांतरित करें
  • गंतव्य के लिए अब सहायक टॉवर में मौजूद एन -1 डिस्क को स्थानांतरित करें
    टॉवर, एक सहायक के रूप में स्रोत टावर का उपयोग कर।

जावा में सोर्स कोड:

 private void towersOfHanoi(int n, char source, char destination, char helper) { //Base case, If there is only one disk move it direct from source to destination if(n==1){ System.out.println("Move from "+source+" to "+destination); } else{ //Step1: Move the top n-1 disks from source to helper towersOfHanoi(n-1, source, helper, destination); //Step2: Move the nth disk from source to destination System.out.println("Move from "+source+" to "+destination); /*Step3: Move the n-1 disks(those you moved from source to helper in step1) * from helper to destination, using source(empty after step2) as helper */ towersOfHanoi(n-1, helper, destination, source); } } 

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

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

एक सीएस छात्र के रूप में, आप शायद गणितीय प्रेरण के बारे में सुना होगा। हनोई के टॉवर का पुनरावर्ती समाधान समान रूप से काम करता है – केवल अलग हिस्सा वास्तव में बी और सी के साथ नहीं खोना है क्योंकि पूर्ण टॉवर समाप्त होता है।

साधारण अर्थ में, प्रक्रिया के दौरान किसी भी समय छोटे डिस्क्स को अतिव्यापी करते हुए डिस्क के समान क्रम में तीन परिभाषित टावरों के बीच एक और टावर को भरना है।

चलो 'ए', 'बी' और 'सी' तीन टावर होंगे 'ए' शुरू में 'एन' डिस्क युक्त टॉवर होगा। 'बी' का इस्तेमाल मध्यवर्ती टॉवर के रूप में किया जा सकता है और 'सी' लक्ष्य टावर है।

एल्गो इस प्रकार है:

  1. 'सी' का उपयोग करके 'ए' से 'बी' तक एन -1 डिस्क ले जाएं
  2. 'ए' से 'सी' में एक डिस्क ले जाएं
  3. 'ए' का उपयोग करके टॉवर 'बी' से 'सी' तक एन -1 डिस्क ले जाएं

जावा में निम्नानुसार कोड है:

सार्वजनिक श्रेणी के टॉवरऑफ़ोनी {

 public void TOH(int n, int A , int B , int C){ if (n>0){ TOH(n-1,A,C,B); System.out.println("Move a disk from tower "+A +" to tower " + C); TOH(n-1,B,A,C); } } public static void main(String[] args) { new TowerOfHanoi().TOH(3, 1, 2, 3); } 

}

यहाँ विवरण जाता है तस्वीर को देखो ->

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

Movetower(3,a,b,c) कॉल करके, आप सभी 3 डिस्क को टॉवर A से टॉवर B स्थानांतरित करने का इरादा रखते हैं। तो अनुक्रमिक कॉल हैं ->

 1. Movetower(3,a,b,c) // No Move needed 2. Movetower(2,a,c,b) // No move needed 3. Movetower(1,a,b,c) // Here is the time to move, move disc1 from a to b 4. Movetower(2,a,c,b) // Returning to this call again, this is the time to move disc2 from a to c 5. Movetower(1,b,c,a) // Again the time to move, this time disc1 from b to c 6. Movetower(3,a,b,c) // Returning to this call again, this is the time to move disc3 from a to b 7. Movetower(2,c,b,a) // Not the time to move 8. Movetower(1,c,a,b) // Here is the time to move, move disc1 from c to a 9. Movetower(2,c,b,a) // Returning to this call again, this is the time to move disc2 from c to b 10.Movetower(1,c,a,b) // Here is the time to move, move disc1 from a to b 

आशा करता हूँ की ये काम करेगा 🙂

एनीमेशन के लिए: https://www.cs.cmu.edu/~cburch/survey/recurse/hanoiex.html

गोलांग के साथ पुनरावर्ती का उपयोग करते हुए हनोई समस्या के टावर्स के लिए यहां मेरा समाधान कोड है I `पैकेज मुख्य

 import "fmt" func main() { toi(4, "src", "dest", "swap") } func toi(n int, from, to, swap string) { if n == 0 { return } if n == 1 { fmt.Printf("mov %v %v -> %v\n", n, from, to) return } toi(n-1, from, swap, to) fmt.Printf("mov %v %v -> %v\n", n, from, to) toi(n-1, swap, to, from) }` 

Tower (N,source,aux.dest):

  1.  if N =1 Then Write : Source -> dest return end of if 
  2. एन-1 डिस्क को खूंटी स्रोत से खूंटी तक ले जाएं

     call Tower (N-1, source, dest, aux) 
  3. स्रोत लिखें -> गंतव्य
  4. एन -1 डिस्क को खूंटी आक्स से पेग डेस्ट में ले जाएँ

     call Tower (N-1, source, dest, aux) 
  5. वापसी

/ ** * * / पैकेज com.test.recursion;

/ ** * @ लेखक kamals1986 हनोई समस्या के टॉवर के पुनरावर्ती एल्गोरिथ्म * एल्गोरिथ्म शक्ति (2, एन) से बढ़ता है। * / सार्वजनिक कक्षा टॉवरओफनोई {

 private static String SOURCE_PEG = "B"; private static String SPARE_PEG = "C"; private static String TARGET_PEG = "A"; public void listSteps(int n, String source, String target, String spare) { if (n == 1) { System.out.println("Please move from Peg " + source + "\tTo Peg\t" + target); } else { listSteps(n - 1, source, spare, target); listSteps(1, source, target, spare); listSteps(n - 1, spare, target, source); } } public static void main(String[] args) { long startTime = System.currentTimeMillis(); new TowerOfHanoi().listSteps(18, SOURCE_PEG, TARGET_PEG, SPARE_PEG); long endTime = System.currentTimeMillis(); System.out.println("Done in " + (endTime - startTime) / 1000 + "\t seconds"); } 

}

 def Hanoi(n, A, B, C): if(n==1): print "move plates to empty peg" else: Hanoi(n-1, A, B, C) print "move"+str(n)+" to peg "+C Hanoi(n-1, B, C, A) 

मैं भी पुनरावर्ती प्राप्त करने की कोशिश कर रहा हूं

मुझे लगता है कि एक रास्ता मिल गया,

मैं इसे कदम की एक श्रृंखला की तरह लगता है (चरण स्थिर नहीं है यह पिछले नोड के आधार पर बदल सकता है)

मुझे 2 चीजों को समझना होगा:

  1. पिछले नोड
  2. कदम तरह
  3. चरण के बाद और कॉल से पहले क्या (यह अगले कॉल के लिए तर्क है

उदाहरण

कारख़ाने का

1,2,6,24,120 ……… या

1,2 * (1), 3 * (2 * 1), 4 * (3 * 2 * 1,5 * (4 * 3 * 2 * 1)

चरण = पिछले नोड से एकाधिक

चरण के बाद जो मुझे अगले नोड पर जाना होगा, सार 1

ठीक

 function = n*f(n-1) its 2 steps process from a-->to step--->b 

मैं इस मदद की उम्मीद की, बस के बारे में 2 thniks लगता है, नोड से नोड कैसे प्राप्त करने के लिए, लेकिन नोड -> कदम -> नोड

नोड -> चरण फ़ंक्शन चरण का मुख्य भाग है -> नोड अन्य फ़ंक्शन के तर्क है

अलविदा 🙂 आशा है कि मैं मदद की