के लिए

Question

का पुनरावृत्ति मुझे यह पता लगाने की कोशिश की गई है कि इसे काफी समय तक कैसे किया जाए और यह इरादे से काम नहीं कर रहा है; मैं एक कोड लिख रहा हूं जहां 1 से के नंबर हैं, मुझे दोहराने के बिना सभी संभव संयोजन खोजने की जरूरत है। जैसे 3 के लिए: 1, 2, 3, 12, 13.

1 के साथ, 2, 3, 4 4 अंक संख्या की गणना के लिए उदाहरण के लिए, 5.

int k = 5; 
for (int p = 0; p < k; p++) 
{ 
    for (int i = p+1; i < k; i++) 
    { 
     for (int j = i + 1; j < k; j++) 
     { 
      for (int h = j + 1; h < k; h++) 
      { 
       cout << p + 1 << i + 1 << j + 1 << h + 1 << endl; 
      } 
     } 
    } 
} 

और वहाँ 3-अंक के लिए उदाहरण है संख्या 1, 2, 3.

int k = 4 
for (int p = 0; p < k; p++) 
{ 
    for (int i = p+1; i < k; i++) 
    { 
     for (int j = i + 1; j < k; j++) 
     { 
      cout << p + 1 << i + 1 << j + 1 << endl; 
     } 
    } 
} 

मुझे लगता है कि दोहराए बिना एन-अंकों की संभावित स्थिति को गिनने के लिए मुझे एन की आवश्यकता है। और मुझे नहीं पता कि बिना किसी घुसपैठ के इसे कैसे किया जाए जो मैं इसे करने पर काम नहीं करता। मेरा लक्ष्य रिकर्सन प्राप्त करना है जो एन-अंकों के लिए संभावित पदों की गणना और प्रिंट करेगा।

Answer 1

मुझे लगता है कि यह आपको बहुत करीब ले जाएगा। मैंने कभी-कभी दोहराया है, लेकिन यह आपको सही रास्ते पर स्थापित करना चाहिए।

const int max_depth = 5; // How long your string is 
const int max_digit = 3; // Max digit you are counting to 
int *nums = new int [max_depth]; 

void recurse_count(int depth) 
{ 
    if (depth < max_depth) 
    { 
     for(int i = depth; i <= depth+1; i++) 
     { 
      nums[depth] = i; 
      recurse_count(i+1); 
     } 
    } 
    else 
    { 
     for (int j = 0; j < max_depth; j++) 
      cout<<nums[j]+1; 
     cout<<endl; 
    } 
} 

int main() 
{ 
    recurse_count(0); 
    return 0; 
} 

Answer 2

मैं यकीन नहीं है कि प्रत्यावर्तन सबसे अच्छा विकल्प यहाँ है नहीं कर रहा हूँ, लेकिन आप इसे इस तरह से कर सकता है:

typedef std::vector<int> IV; 
IV getFirst(int k){ 
    IV res; 
    for (int i=0;i<k-1;i++){res.push_back(i+1);} 
    return res; 
} 

bool getNext(IV& numbers,int i){ 
    if (i==-1){return false;} // end of recursion 
    if (numbers[i]>i+1){return getNext(numbers,i-1);} 
    numbers[i]++; 
    return true; 
} 
bool getNext(IV& numbers){ // start of recursion 
    return getNext(numbers,numbers.size()-1); 
} 

int main() { 
    IV numbers = getFirst(5); 
    for (int i=0;i<numbers.size();i++){std::cout << numbers[i];} 
    std::cout << std::endl; 
    while(getNext(numbers)){ 
     for (int i=0;i<numbers.size();i++){std::cout << numbers[i];} 
     std::cout << std::endl; 
    } 
} 

Answer 3

मैं संभावना अपने आप गिनती करने के लिए प्रत्यावर्तन किया था, लेकिन आप अपने सभी की मदद के लिए लोगों से प्यार करता ।

मेरे प्रत्यावर्तन

void col(int ilosc) 
{ 
    static int st; 
    for (int i = st++; i < k; i++) 
    { 
     if (ilosc > 1) 
      col(ilosc - 1); 
     else 
      sposob++; 
    } 
} 

जहां ilosc अंक नंबर और sposob है संभव पदों संख्या की गिनती है।

नोट: sposob और कश्मीर वैश्विक चर है।

Answer 4

मेरे दृष्टिकोण

namespace detail 
{ 
    void recurse_hlp(int min, int max, std::vector<int> vals, std::function<void(const std::vector<int>&)> f, std::size_t ptr) 
    { 
     if (ptr == vals.size()) 
      f(vals); 
     else 
     { 
      for (int i = min; i <= max; ++i) 
      { 
       vals[ptr] = i; 
       recurse_hlp(min, max, vals, f, ptr + 1); 
      } 
     } 
    } 
} 

void recurse(int min, int max, int count, std::function<void(const std::vector<int>&)> f) 
{ 
    std::vector<int> vals(count); 
    detail::recurse_hlp(min, max, vals, f, 0); 
} 

void print(const std::vector<int>& vals) 
{ 
    for (int v : vals) 
     std::cout << v << " "; 
    std::cout << std::endl; 
} 

int main() 
{ 
    recurse(0, 5, 3, &print); 
} 

recurse जो count स्थानों तक min से max को सभी नंबरों को शामिल एक समारोह std::vector<int> स्वीकार हो जाता है (अभी भी बहुत शाम को जल्दी शायद, मैं इसके साथ समस्या नहीं थी)।