Cartesian Product of multiple arrays in C

Question

I am able to achieve cartesian product of static number of arrays in C.But I would like to build a code dynamically taking the number of input arrays.Can someone shed some light how to do this "only using arrays".If it's not possible with arrays please suggest me other solution.Thank you.Here is my code below for cartesian product of 3 arrays.

#include<stdio.h>

int main(void)
{
        int array1[100];
        int array2[100];
        int array3[100];
        int cartesian_array[100][100];
        int m,n,o;
        int i,j;
        int p=0,q=0,r=0;
        int x,y,z;
        int cartesian_arr_row_len;
        int cartesian_arr_col_len;


        printf("Enter the size of first array:\n");
        scanf("%d",&m);

        printf("Enter the size of second array:\n");
        scanf("%d",&n);

        printf("Enter the size of third array:\n");
        scanf("%d",&o);

        printf("Enter the first array elements:\n");
        for(i=0;i<m;i++)
        scanf("%d",&array1[i]);

        printf("Enter the second array elements:");
        for(i=0;i<n;i++)
        scanf("%d",&array2[i]);

        printf("Enter the third array elements:");
        for(i=0;i<o;i++)
        scanf("%d",&array3[i]);

        cartesian_arr_row_len=m*n*o;
        cartesian_arr_col_len=3;

        x=cartesian_arr_row_len/m;
        y=cartesian_arr_row_len/(m*n);
        z=o;

        for(i=0;i<cartesian_arr_row_len;i++)
        {
                for(j=0;j<cartesian_arr_col_len;j++)
                {
                        if(j==0)
                        {
                                cartesian_array[i][j]=array1[p/x];
       p++;
                        }

                        if(j==1)
                        {
                                cartesian_array[i][j]=array2[q/y];
                                q++;
                                if(q>=n*y)
                                q=0;
                        }

                        if(j==2)
                        {
                                cartesian_array[i][j]=array3[r%z];
                                r++;
                        }
                }

        }

        printf("The Cartesian Product of two arrays is:\n");
        for(i=0;i<cartesian_arr_row_len;i++)
        {
                for(j=0;j<cartesian_arr_col_len;j++)
                {
                        printf("%d\t",cartesian_array[i][j]);
                }
                printf("\n");
        }

        return 0;
}

Answer 1

Can you read Java code, and translate it yourself?

import java.util.*;    

class CartesianIterator <T> implements Iterator <List <T>> {

        private final List <List <T>> lilio;    
        private int current = 0;
        private final long last;

        public CartesianIterator (final List <List <T>> llo) {
                lilio = llo;
                long product = 1L;
                for (List <T> lio: lilio)
                        product *= lio.size ();
                last = product;
        } 

        public boolean hasNext () {
                return current != last;
        }

        public List <T> next () {
                ++current;
                return get (current - 1, lilio);
        }

        public void remove () {
                ++current;
        }

        private List<T> get (final int n, final List <List <T>> lili) {
                switch (lili.size ())
                {
                        case 0: return new ArrayList <T> (); // no break past return;
                        default: {
                                List <T> inner = lili.get (0);
                                List <T> lo = new ArrayList <T> ();
                                lo.add (inner.get (n % inner.size ()));
                                lo.addAll (get (n / inner.size (), lili.subList (1, lili.size ())));
                                return lo;
                        }
                }
        }
}

class CartesianIterable <T> implements Iterable <List <T>> {

        private List <List <T>> lilio;  

        public CartesianIterable (List <List <T>> llo) {
                lilio = llo;
        }

        public Iterator <List <T>> iterator () {
                return new CartesianIterator <T> (lilio);
        }
}

class CartesianIteratorTest {

        public static void main (String[] args) {
                List <Character> la = Arrays.asList (new Character [] {'a', 'b'});
                List <Character> lb = Arrays.asList (new Character [] {'b', 'c'});      
                List <Character> lc = Arrays.asList (new Character [] {'c', 'a'});
                List <List <Character>> llc = new ArrayList <List <Character>> ();
                llc.add (la);
                llc.add (lb);
                llc.add (lc);

                CartesianIterable <Character> ci = new CartesianIterable <Character> (llc);
                for (List<Character> lo: ci)
                        show (lo);

                la = Arrays.asList (new Character [] {'x', 'y', 'z'});
                lb = Arrays.asList (new Character [] {'b'});    
                lc = Arrays.asList (new Character [] {'c'});
                llc = new ArrayList <List <Character>> ();
                llc.add (la);
                llc.add (lb);
                llc.add (lc);

                ci = new CartesianIterable <Character> (llc);
                for (List<Character> lo: ci)
                        show (lo);
        }

        public static void show (List <Character> lo) {
                System.out.print ("(");
                for (Object o: lo)
                        System.out.print (o);
                System.out.println (")");
        }
}

I don't know whether iterator-similar thing exists in C. The iterable is most probably of no help for you.

The idea of the code is, to have a counter, which creates an index over all elements of the resultset, and calculate the element, bound to that value.

If we have 3 groups (1,2,3)(4,5)(6,7,8), we have 18=3x2x3 results we expect. We can, for Iterator position 7 for example calculate the result as follows:

7 % 3 = 1 => (1,2,3)[1] = 2 (number modulo 1st group size) 
7 / 3 = 2 (int division)  (number div 1st group size)
2 % 2 = 0 => (4,5)[0] = 4 (rest modulo 2nd group size) 
2 / 2 = 0 
0 % 3 = 0 => (7,8,9) => 7 

idx g1  g2  g3
 0  1   4   6   
 1  2   4   6   
 2  3   4   6   
 3  1   5   6   
 4  2   5   6   
 5  3   5   6   
 6  1   4   7   
 7  2   4   7   
 8  3   4   7   
 9  1   5   7   
10  2   5   7   
11  3   5   7   
12  1   4   8   
13  2   4   8   
14  3   4   8   
15  1   5   8   
16  2   5   8   
17  3   5   8