Computer >> कंप्यूटर >  >> प्रोग्रामिंग >> C++

C++ में शब्द सूचियों की सूची से बनने वाले सभी वाक्यों को पुनरावर्ती रूप से प्रिंट करें


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

आइए इसके लिए विभिन्न इनपुट आउटपुट परिदृश्य देखें

इनपुट -

sentence[row][col] = {{"I", "You"},
   {"Do", "do not like"},
   {"walking", "eating"}}

आउटपुट -

I Do walking
I Do eating
I like walking
I like eating
You Do walking
You Do eating
You like walking
You like eating

स्पष्टीकरण − वाक्य में प्रत्येक सूची से एक शब्द लेने पर[0-2] उपरोक्त वाक्य देता है।

इनपुट -

sentence[row][col] = {{"work", "live"},{"easy", "happily"}}

आउटपुट -

work easy
work happily
live easy
live happily

स्पष्टीकरण − वाक्य में प्रत्येक सूची से एक शब्द लेने पर[0-1] उपरोक्त वाक्य देता है।

  • स्ट्रिंग प्रकार की 2-डी सरणी को वाक्य [पंक्ति] [col] के रूप में घोषित करें। फ़ंक्शन को डेटा को रिकर्सिव_प्रिंट (वाक्य) के रूप में पास करें।

  • फ़ंक्शन के अंदर रिकर्सिव_प्रिंट (वाक्य) के रूप में

    • एआर [पंक्ति] के रूप में टाइप स्ट्रिंग की एक सरणी बनाएं।

    • I से 0 तक के लिए लूप प्रारंभ करें जब तक कि i col से कम न हो। लूप के अंदर, IF वाक्य की जाँच करें [0] [i] खाली नहीं है, फिर फ़ंक्शन को रिकर्सन (वाक्य, 0, i, arr) के रूप में कॉल करें।

  • फ़ंक्शन के अंदर रिकर्सन के रूप में (स्ट्रिंग वाक्य [पंक्ति] [col], int temp_1, int temp_2, string arr [row])

    • गिरफ्तारी [temp_1] को वाक्य [temp_1][temp_2] पर सेट करें।

    • जांचें कि क्या temp_1 पंक्ति -1 है, फिर i से 0 तक के लिए लूप प्रारंभ करें जब तक कि पंक्ति से कम न हो। लूप के अंदर, arr[i] प्रिंट करें।

    • I से 0 तक के लिए लूप प्रारंभ करें जब तक कि i col से कम न हो। लूप के अंदर, IF वाक्य की जाँच करें [temp_1+1][i] स्पेस के बराबर नहीं है, फिर फ़ंक्शन को रिकर्सन (वाक्य, temp_1+1, i, arr) के रूप में पुनरावर्ती कॉल करें।

  • परिणाम प्रिंट करें।

नीचे दिए गए प्रोग्राम में इस्तेमाल किया गया तरीका इस प्रकार है

उदाहरण

#include<bits/stdc++.h>
#define row 3
#define col 3
using namespace std;
void Recursion(string sentence[row][col], int temp_1, int temp_2, string arr[row]){
   arr[temp_1] = sentence[temp_1][temp_2];
   if(temp_1 == row - 1){
      for(int i=0; i < row; i++){
         cout << arr[i] << " ";
      }
      cout << endl;
      return;
   }
   for(int i=0; i < col; i++){
      if(sentence[temp_1+1][i] != ""){
         Recursion(sentence, temp_1+1, i, arr);
      }
   }
}
void Recursive_Print(string sentence[row][col]){
   string arr[row];
   for(int i=0; i < col; i++){
      if(sentence[0][i] != ""){
         Recursion(sentence, 0, i, arr);
      }
   }
}
int main(){
   string sentence[row][col] = {{"Ajay", "sanjay"},{"Like", "is"},{"Reading", "eating"}};
   Recursive_Print(sentence);
   return 0;
}

आउटपुट

यदि हम उपरोक्त कोड चलाते हैं तो यह निम्न आउटपुट उत्पन्न करेगा

Ajay Like Reading
Ajay Like eating
Ajay is Reading
Ajay is eating
sanjay Like Reading
sanjay Like eating
sanjay is Reading
sanjay is eating

  1. C++ में दिए गए नोड से k दूरी पर सभी नोड्स प्रिंट करें

    इस समस्या में, हमें एक बाइनरी ट्री, एक लक्ष्य नोड और एक पूर्णांक K दिया जाता है। हमें ट्री के सभी नोड्स को प्रिंट करना होता है जो लक्ष्य नोड से K की दूरी पर होते हैं। । बाइनरी ट्री एक विशेष पेड़ है जिसके प्रत्येक नोड में अधिकतम दो नोड (एक/दो/कोई नहीं) होते हैं। आइए समस्या को समझने के लिए एक उदाहरण

  1. C++ में लीफ नोड से k दूरी पर मौजूद सभी नोड्स को प्रिंट करें

    इस समस्या में, हमें एक बाइनरी ट्री और एक नंबर K दिया जाता है। हमें ट्री के सभी नोड्स को प्रिंट करना होता है जो लीफ नोड से k दूरी पर होते हैं। बाइनरी ट्री एक विशेष पेड़ है जिसके प्रत्येक नोड में अधिकतम दो नोड (एक/दो/कोई नहीं) होते हैं। लीफ नोड बाइनरी ट्री का नोड ट्री के अंत में होता है। इस समस्या

  1. किसी दिए गए स्रोत से गंतव्य तक सभी पथों को C++ में प्रिंट करें

    इस समस्या में हमें एक निर्देशित ग्राफ़ दिया जाता है और हमें स्रोत से ग्राफ़ के गंतव्य तक के सभी पथों को प्रिंट करना होता है। निर्देशित ग्राफ़ किनारों वाला एक ग्राफ़ है जो शीर्ष a से b तक निर्देशित होता है। समस्या को समझने के लिए एक उदाहरण लेते हैं स्रोत =के गंतव्य =पी आउटपुट: K -> T -&