Question: Given `x` number of arrays, each with a possibly different number of elements, how can I iterate through all combinations where I select one item from each array?

Example:

```
[   ]   [   ]   [   ]
 foo     cat      1
 bar     dog      2
 baz              3
                  4

```

Returns

```
[foo]   [cat]   [ 1 ]
[foo]   [cat]   [ 2 ]
  ...
[baz]   [dog]   [ 4 ]

```

I'm doing this in Perl, btw.

Answer: 
Recursive and more-fluent Perl examples (with commentary and documentation) for doing the Cartesian product can be found at <http://www.perlmonks.org/?node_id=7366>

Example:

```
sub cartesian {
    my @C = map { [ $_ ] } @{ shift @_ };

    foreach (@_) {
        my @A = @$_;

        @C = map { my $n = $_; map { [ $n, @$_ ] } @C } @A;
    }

    return @C;
}

```
There's one method I thought of first that uses a couple for loops and no recursion.

1. find total number of permutations
2. loop from 0 to total\_permutations-1
3. observe that, by taking the loop index modulus the number of elements in an array, you can get every permutations

Example:

Given A[3], B[2], C[3],

```
for (index = 0..totalpermutations) {
    print A[index % 3];
    print B[(index / 3) % 2];
    print C[(index / 6) % 3];
}

```

where of course a for loop can be substituted to loop over [A B C ...], and a small part can be memoized. Of course, recursion is neater, but this might be useful for languages in which recursion is severely limited by stack size.