Question

I’m having difficulty with this recursion problem. I thought I had an answer to it but it doesn’t work, and I simply don’t know why, so I thought I would ask the experts. Please go easy on me, I took C programming more than 15 years ago and even then I was maybe a B student. I don’t know C++ or Java.

The purpose is to generate all of the possible combinations of integers from 0 to (n[j]-1), where j can be an arbitrary integer. Right now it is hard-coded as 2, but I would like it to be able to take any value eventually.

Anyway, here is my code. Thanks in advance for your help.

Edit:
For the code below, I define 2 sequences, with the 0th sequence having a length of 2 (0,1) and the 1st sequence having a length of 3 (0, 1, 2).
The desired output is as follows:

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

That is,

• the 0th combination contributes 0 from sequence 0 and 0 from sequence 1
• the 1st combination contributes 0 from sequence 0 and 1 from sequence 1
• the 2nd combination contributes 0 from sequence 0 and 2 from sequence 1
• the 3rd combination contributes 1 from sequence 0 and 0 from sequence 1
• the 4th combination contributes 1 from sequence 0 and 1 from sequence 1
• the 5th combination contributes 1 from sequence 0 and 2 from sequence 1

I hope this makes it clearer what I’m trying to do!

#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);
}