Rekursion von für

Question

Ich bin versucht, herauszufinden, wie es für ziemlich lange Zeit und es funktioniert nicht wie vorgesehen; Ich schreibe einen Code, wo es 1 bis k Zahlen gibt, ich muss alle möglichen Kombinationen ohne Wiederholungen finden. z.B. 3: 1, 2, 3, 12, 13

Beispiel zum Zählen 4-stellige Zahlen mit 1, 2, 3, 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; 
      } 
     } 
    } 
} 

Und es ist beispielsweise für 3-stellig Zahl mit 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; 
     } 
    } 
} 

denke ich, dass n-Ziffern möglich Position ohne Wiederholung zu zählen ich brauche n für die. Und ich weiß nicht, wie man es ohne Rekursion macht, die nicht funktionieren, wenn ich es tue. Mein Ziel ist Rekursion, die mögliche Positionen für n-Ziffern zählt und druckt.

Answer 1

Ich denke, das wird dir ziemlich nahe kommen. Ich wiederhole gelegentlich, aber das sollte dich auf den richtigen Weg bringen.

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

Ich bin nicht sicher, ob Rekursion hier die beste Wahl ist, aber man es so tun könnte:

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

Ich habe Rekursion Möglichkeit, mich zu zählen, aber lieben euch für eure Hilfe .

Meine Rekursion ist

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

wo ilość ist stellige Nummer und sposob Anzahl der möglichen Positionen Zahlen.

HINWEIS: sposob und k ist globale Variablen.

Answer 4

Mein Ansatz (noch zu früh am Abend wahrscheinlich hatte ich Probleme mit ihm)

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 bekommen eine Funktion std::vector<int> zu akzeptieren, die alle Zahlen min-max bis zu count Orten enthalten.