Printing every possible pair combination of elements in two arrays??

Question

Hi there,
I'm trying to implement the problem of printing every possible pair combination of elements in two arrays. The pattern I have in mind is very simple, I just don't know how to implement it. Here's an example:
g[3] = {'A', 'B', 'C'}
h[3] = {1, 2, 3}
...code...??
Expected Output:
A = 1
B = 2
C = 3
A = 1
B = 3
C = 2
A = 2
B = 1
C = 3
A = 2
B = 3
C = 1
A = 3
B = 1
C = 2
A = 3
B = 2
C = 1
The code should work for any array size, as long as both arrays are the same size. Anybody know how to code this??
Cheers,
Sean

Answer 1

not a big fan of Java recursion, unless tail recursion, otherwise you are bound to have out of stack error. Here is some generic permutation method I wrote a while back:
It is generic enough, should serve your purpose.
* The method returns all permutations of given objects.  The input array is a two-dimensionary, with the 1st dimension being
* the number of buckets (or distributions), and the 2nd dimension contains all possible items for each of the buckets.
* When constructing the actual all permutations, the following logic is used:
* take the following example:
* 1    2    3
* a    d    f
* b    e    g
* c
* has 3 buckets (distributions): 1st one has 3 items, 2nd has 2 items and 3rd has 2 items as well.
* All possible permutaions are:
* a    d    f
* a    d    g
* a    e    f
* a    e    g
* b    d    f
* b    d    g
* b    e    f
* b    e    g
* c    d    f
* c    d    g
* c    e    f
* c    e    g
* You can see the pattern, every possiblity of 3rd bucket is repeated once, every possiblity of 2nd bucket is repeated twice,
* and that of 1st is 4.  The number of repetition has a pattern to it, ie: the multiplication of permutation of all the
* args after the current one.
* Therefore: 1st bucket has 2*2 = 4 repetition, 2nd has 2*1 = 2 repetition while 3rd being the last one only has 1.
* The method returns another two-dimensional array, with the 1st dimension represent the number of permutations, and the 2nd
* dimension being the actual permutation.
* Note that this method does not purposely filter out duplicated items in each of given buckets in the items, therefore, if
* is any duplicates, then the output permutations will contain duplicates as well.  If filtering is needed, use
* filterDuplicates(Obejct[][] items) first before calling this method.
public static Object[][] returnPermutation(Object[][] items)
     int numberOfPermutations = 1;
     int i;
     int repeatNum = 1;
     int m = 0;
     for(i=0;i<items.length;i++)
          numberOfPermutations = numberOfPermutations * items.length;
     int[] dimension = {numberOfPermutations, items.length};
     Object[][] out = (Object[][])Array.newInstance(items.getClass().getComponentType().getComponentType(), dimension);
     for(i=(items.length-1);i>=0;i--)
          m = 0;
          while(m<numberOfPermutations)
               for(int k=0;k<items[i].length;k++)
                    for(int l=0;l<repeatNum;l++)
                         out[m][i] = items[i][k];
                         m++;
          repeatNum = repeatNum*items[i].length;
     return out;
/* This method will filter out any duplicate object in each bucket of the items
public static Object[][] filterDuplicates(Object[][] items)
     int i;
     Class objectClassType = items.getClass().getComponentType().getComponentType();
     HashSet filter = new HashSet();
     int[] dimension = {items.length, 0};
     Object[][] out = (Object[][])Array.newInstance(objectClassType, dimension);
     for(i=0;i<items.length;i++)
          filter.addAll(Arrays.asList(items[i]));
          out[i] = filter.toArray((Object[])Array.newInstance(objectClassType, filter.size()));
          filter.clear();
     return out;