Recursion of for

Question

Ho cercato di capire come farlo per un po 'di tempo e non funziona come previsto; Sto scrivendo un codice dove ci sono numeri da 1 a k, ho bisogno di trovare tutte le combinazioni possibili senza ripetizioni. per esempio. da 3: 1, 2, 3, 12, 13.

Esempio per contare numeri a 4 cifre con 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; 
      } 
     } 
    } 
} 

E c'è esempio per 3-cifre numero con 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; 
     } 
    } 
} 

Penso che per contare le n cifre possibile posizione senza ripetere ho bisogno di n for's. E non so come farlo senza ricorsione che non funziona quando lo faccio. Il mio obiettivo è ottenere la ricorsione che conterà e stamperà le possibili posizioni per n-cifre.

Answer 1

Penso che questo ti porterà molto vicino. Ho una ripetizione occasionale qui, ma questo dovrebbe metterti sulla giusta strada.

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

io non sono sicuro se la ricorsione è la scelta migliore qui, ma si potrebbe fare in questo modo:

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

ho fatto la ricorsione per contare la possibilità di me, ma ti amo ragazzi per tutto il vostro aiuto .

mio ricorsione è

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

dove ilość è il numero cifre e spôsob è conteggio dei numeri possibili posizioni.

NOTA: sposob e k è variabile globale.

Answer 4

Il mio approccio (ancora troppo presto la sera, probabilmente, ho avuto problemi con esso)

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 ottiene una funzione di accettare std::vector<int>, che contiene tutti i numeri da min a max fino a count posti.