присвоение всех комбинаций переменного числа переменных объектов

Question

У меня возникла проблема с этой проблемой рекурсии. Я думал, что у меня есть ответ на это, но это не сработает, и я просто не знаю, почему, поэтому я подумал, что попрошу экспертов. Прошу прощаться со мной, я занимался программированием на C более 15 лет назад, и даже тогда я был, возможно, студентом B. Я не знаю C++ или Java.

Целью является создание всех возможных комбинаций целых чисел от 0 до (n [j] -1), где j может быть произвольным целым числом. Сейчас он жестко закодирован как 2, но я хотел бы, чтобы он мог в любой момент получить какое-либо значение.

В любом случае, вот мой код. Заранее спасибо за вашу помощь.

Редактировать: Для кода ниже я определяю 2 последовательности, причем 0-я последовательность имеет длину 2 (0,1) и 1-ю последовательность, имеющую длину 3 (0, 1, 2). Нужный выход следующим образом:

p[0][0] = 0 
p[0][1] = 0 
p[1][0] = 0 
p[1][1] = 1 
p[2][0] = 0 
p[2][1] = 2 
p[3][0] = 1 
p[3][1] = 0 
p[4][0] = 1 
p[4][1] = 1 
p[5][0] = 1 
p[5][1] = 2 

То есть,

• 0-я комбинация способствует 0 из последовательности 0 и 0 из последовательности 1
• 1-й комбинации способствует 0 из последовательности 0 и 1 из последовательности 1
• 2-я комбинация вносит 0 из последовательности 0 и 2 из последовательности 1
• 3-я комбинация вносит 1 из последовательности 0 и 0 f последовательность ПЗУ 1
• 4-й сочетание способствует 1 из последовательности 0 и 1 из последовательности 1
• 5-й сочетание способствует 1 из последовательности 0 и 2 из последовательности 1

Я надеюсь, что это делает его более ясным, что я м пытается сделать!

#include <stdio.h> 
#include <stdlib.h> 

int recurse (int **p, int *n, int nclass, int classcount, int combcount); 

int recurse (int **p, int *n, int nclass, int classcount, int combcount) 
{ 
    int k, j, kmax; 
    kmax = n[classcount]; 
    j = classcount; 

    if (j == nclass) { 
    return (combcount+1); 
    } 

    for (k = 0; k < kmax; k++) { 
    p[combcount][j] = k; 
    combcount = recurse (p, n, nclass, j+1, combcount); 
    } 
} 

int main (void) 
{ 
    int **p, n[2], i, j; 

    n[0] = 2; 
    n[1] = 3; 

    p = (int **) malloc ((n[0]*n[1]) * sizeof (int *)); 
    for (i = 0; i < (n[0]*n[1]); i++) { 
    p[i] = (int *) malloc (2 * sizeof (int)); 
    for (j = 0; j < 2; j++) 
     p[i][j] = -1; 
    } 

/* p[i][j] = the value of the integer in the ith combination 
    arising from the sequence 0...n[j]-1 */ 

    recurse (p, n, 2, 0, 0); 

    for (i = 0; i < (n[0]*n[1]); i++) 
    for (j = 0; j < 2; j++) 
     printf ("%d %d: %d\n", i, j, p[i][j]); 

    for (i = 0; i < (n[0]*n[1]); i++) 
    free (p[i]); 
    free (p); 
    return (0); 
} 

Answer 1

#include <stdio.h> 
#include <stdlib.h> 

void recurse(int *n, int *accum, int **p, int N, int k) { 
    static int comb; 
    int i, j; 
    if (k == 0) 
     comb = 0; 
    if (k == N) { 
     for (i = 0; i < N; ++i) 
      p[comb][i] = accum[i]; 
     comb++; 
    } 
    else 
     for (i = 0; i < n[k]; ++i) { 
      accum[k] = i; 
      recurse(n, accum, p, N, k+1); 
     } 
} 

int main(void) { 
    const int N = 2; 
    int n[N]; 
    int accum[N]; 
    int **p; 
    int mult; 
    int i, j; 
    n[0] = 2; 
    n[1] = 3; 
    for (mult = 1, i = 0; i < N; mult *= n[i], ++i); 
    p = malloc(mult*sizeof(int*)); 
    for (i = 0; i < mult; i++) 
     p[i] = malloc(N*sizeof(int)); 
    recurse(n, accum, p, N, 0); 
    for (i = 0; i < mult; ++i) 
     for (j = 0; j < N; ++j) 
      printf("p[%d][%d] = %d\n", i, j, p[i][j]); 
    for (i = 0; i < mult; i++) 
     free(p[i]); 
    free(p); 
} 

Answer 2

#include <stdio.h> 
#include <stdlib.h> 

int recurse (int **p, int *n, int nclass, int classcount, int p_size){ 
    int i, j, jmax, k, kmax; 

    if (classcount == nclass) return 1; 

    i = 0; 
    kmax = n[classcount]; 
    while(i < p_size){ 
     for (k = 0; k < kmax; ++k){ 
      jmax = recurse (p, n, nclass, classcount+1, p_size); 
      for(j = 0;j < jmax; ++j) 
       p[i++][classcount] = k; 
     } 
    } 
    return kmax*jmax; 
} 

int main (void){ 
    int **p, n[2], i, j; 
    int sizeAll, sizeN; 

    n[0] = 2; 
    n[1] = 3; 
    sizeAll = n[0]*n[1]; 
    sizeN = sizeof(n)/sizeof(int); 
    p = (int **) malloc (sizeAll * sizeof (int *)); 
    for (i = 0; i < sizeAll; ++i) { 
     p[i] = (int *) malloc (sizeN * sizeof (int)); 
     for (j = 0; j < sizeN; ++j) 
      p[i][j] = -1; 
    } 

    recurse (p, n, sizeN, 0, sizeAll); 

    for (i = 0; i < sizeAll; ++i) 
     for (j = 0; j < sizeN; ++j) 
      printf ("%d %d: %d\n", i, j, p[i][j]); 

    for (i = 0; i < sizeAll; ++i) 
     free (p[i]); 
    free (p); 
    return (0); 
}