सी/सी ++/जावा/सी #

Question

में रिकर्सन समाधान का एक अच्छा बैंक मैंने this question देखा, लेकिन उत्तर बहुत प्रासंगिक नहीं हैं। एक दोस्त को कल परीक्षण के लिए अध्ययन करने में मदद करने के लिए हल की गई रिकर्सन समस्याओं के एक बैंक की आवश्यकता है।

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

नोट - कार्यात्मक भाषाओं में उदाहरण यहां बहुत मदद नहीं करेंगे। मेरा दोस्त कल अपनी परीक्षा उत्तीर्ण करने के लिए एक अध्ययन दौड़ में है, और मुझे यकीन है कि भाषाएं स्विच करने से उसे इस बिंदु पर भ्रमित कर दिया जाएगा (यह अन्य, कम तनाव वाले समय पर शैक्षिक हो सकता है)।

Answer 1

This article प्रत्यावर्तन बताते हैं और लिंक की गई सूची और द्विआधारी पेड़

Answer 2

रिकर्सन सीखने के सर्वोत्तम तरीकों में से एक है एक कार्यात्मक प्रोग्रामिंग भाषा जैसे हास्केल या लिस्प या योजना में कुछ अनुभव प्राप्त करना।

तो रिकर्सिव समस्याओं को खोजने के लिए कुछ समस्याएं और कार्यात्मक प्रोग्रामिंग भाषाओं से संबंधित उत्तरों को खोजने के लिए कम किया जा सकता है। यहां एक उदाहरण 99 lisp problems है।

यह वास्तव में योजना या लिस्प सीखने में केवल 5 मिनट लगते हैं ताकि आप कल बताए गए परीक्षण के लिए उदाहरणों के साथ शुरू कर सकें।

रिकर्सन सीखने का एक और शानदार तरीका है प्रेरण से जुड़े गणितीय सबूत में कुछ अभ्यास करना।

---

कुंजी प्रत्यावर्तन से संबंधित अवधारणाओं:

प्रत्यावर्तन आप कैसे समस्या को हल करने में जानने की जरूरत नहीं है के साथ

। आपको सिर्फ 2 चीजों को जानने की जरूरत है। 1) समस्या का सबसे छोटा उदाहरण कैसे हल करें, और 2) इसे छोटे हिस्सों में कैसे विभाजित करें।

समतुल्य रूप से, आपको केवल यह ध्यान रखना होगा कि आपको आवश्यकता है: 1) आधार मामला और 2) एक पुनरावर्ती मामला।

बेस केस छोटे इनपुट के साथ आप जो करना चाहते हैं उसके 1 एकल उदाहरण को संभालता है।

रिकर्सिव केस समस्या को उपप्रोबलेम में तोड़ देता है। आखिरकार यह सबप्रोबलेम बेस केस को कम कर देगा।

उदाहरण:

//1+...+n = n*n(+1)/2 = sumAll(n): 

int sumAll(int x) 
{ 
    if(x == 0) //base case 
    return 0; 
    else 
    return sumAll(x-1) + x; //recursive case 
} 

यह समझना महत्वपूर्ण है कि आधार मामला समझ पाना कठिन नहीं है महत्वपूर्ण है। यह सिर्फ अस्तित्व में है। यहाँ x> 0 के लिए एक समान समाधान है:

//1+...+n = n*n(+1)/2 = sumAll(n): 
int sumAll(int x) 
{ 
    if(x == 1) //base case 
    return 1; 
    else 
    return sumAll(x-1) + x; //recursive case 
} 

Answer 3

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

आप अध्ययन करने की संभावित दिशा के लिए उसे Project Euler पर ध्यान देना चाहते हैं।

Answer 4

मुझे लगता है कि हास्केल का वाक्यविन्यास दोबारा सोचने के लिए बहुत अच्छा है, क्योंकि पैटर्न मिलान करने वाला निर्माण बेस केस और रिकर्सिव केस को इतना स्पष्ट बनाता है। इसे किसी अन्य भाषा में अनुवाद करना काफी सरल है।

sumAll [] = 0 
sumAll (x:xs) = x + sumAll xs 

यह समझने के लिए, आप वास्तव में केवल पता चला है कि

• [] एक खाली सूची का प्रतिनिधित्व करता है, जरूरत है
• (एक्स: XS) एक सिर में एक सूची विभाजन (x) और एक पूंछ (xs)

आपको सभी हास्केल (जो है, चलो इसका सामना करना मुश्किल है) सीखने की आवश्यकता नहीं है - लेकिन कुछ मूलभूत बातें निश्चित रूप से आपको रिकर्सन में सोचने में मदद करती हैं।

Answer 5

पढ़ें SICP (संरचना और कंप्यूटर प्रोग्राम की व्याख्या)

Answer 6

#include<iostream> 
using namesspace std; 
int E(int x); 
int main() 
{ 
    int x; 
    cout << E(x) << endl; 
    return 0; 
} 

int E(int x) 
{ 
    return x ? (x % 10 + E(x/10)) : 0; 
} 

Answer 7

traversing भाषा सी/सी ++ में एक समारोह कॉल कर सकते हैं के लिए कुछ सरल सी उदाहरण है खुद और इस मामले को रिकर्सन कहा जाता है। मुख्य रूप से रिकर्सन में दो मामले होते हैं:

1. बेस केस।
2. रिकर्सिव केस।

और हम जैसे कुछ पुनरावर्ती श्रेणियों है ...

1. लाइनर प्रत्यावर्तन
2. बाइनरी प्रत्यावर्तन
3. नेस्टेड प्रत्यावर्तन
4. म्युचुअल प्रत्यावर्तन
5. पूंछ प्रत्यावर्तन

यहां रिकर्सन पर चर्चा करने के लिए एक उदाहरण लें ...

// a recursive program to calculate NcR // 
#include <stdio.h> 
int ncr(int x,int y) 
{ 
    if(y>x) 
    { 
     printf("!sorry,the operation can't processed."); 
     getch(); 
     exit(1); 
    } 
    else if(y==0 ||y==x) //base case 
    { 
     return(1); 
    } 
    else 
    { 
     return(ncr(x-1,y-1)+ncr(x-1,y)); //recursive case 
    } 
}