0 0 0
1 0 0
2 0 0
3 0 0
0 1 0
0 2 0
0 3 0
0 0 1
1 0 1
2 0 1
3 0 1
0 1 1
0 2 1
(etc)
[download]

my @odometer = (0, 0, 0);
[download]

while_odometer_has_not_run_to_completion... {
  $id2++;
  (
    $data{$id}{$id2}{'key1'},
    $data{$id}{$id2}{'key2'},
    $data{$id}{$id2}{'key3'}, 
  )
    = 
  (
    $hash{$id}{'key1'}[ $odometer[0] ],
    $hash{$id}{'key2'}[ $odometer[1] ],
    $hash{$id}{'key3'}[ $odometer[2] ],
  );
  next_odometer( \@odometer );
}
[download]

If the data-structure being traversed is deep and/or arbitrary, perhaps a tool such as Data::Walker will come in handy.   (There are many tools of this sort on CPAN ...)

These tools, as the name implies, allow you to “walk through” a data structure in a predictable way, regardless of its depth.   Might or might not be apropos in this particular situation, but worth knowing about anyhow.

Thanks im reading up on it now. Meanwhile, i'd like to understand recursion better as this is the first ive come across it and it looks immensely useful for the future.

Conceptually it seems simple enough, a function calling itself but i cant get my head around the details of what the code is doing!

I recommend you start with the Wikipedia article titled Recursion (computer science). And because "recursion is one of the central ideas of computer science," you're going to find explanations and examples of it in any good computer science textbook.

If you have an arbitrarily nested data structure with both arrays and hashes in it, then you're going to need to use the ref function. You'll use an if-then-else construct within your recursive function to decide what to do at each level in the nested data structure.

Set::CrossProduct to the rescue:

use strict;
use warnings;

use Set::CrossProduct;

my %hash=('ID' => {
                  'key1' => [ qw/ key1_val1 key1_val2/ ],
                  'key2' => [ qw/ key2_val1 key2_val2/ ]
                  }
          );



foreach my $id ( keys %hash ) {

    my $keys = $hash{$id};

    my $set = Set::CrossProduct->new( [ values %$keys ] );

    print join( ', ', $id, @$_ ), "\n" while $_ = $set->get;


}
[download]

ID, key2_val1, key1_val1
ID, key2_val1, key1_val2
ID, key2_val2, key1_val1
ID, key2_val2, key1_val2
[download]

#!/usr/bin/perl
use strict;
use warnings;
use Set::CrossProduct;

my %hash=('ID' => {
                  'key1' => ['key1_val1', 'key1_val2'],
                  'key2' => ['key2_val1', 'key2_val2']
                  }
          );

for my $id (keys %hash) {
    my @data = values %{ $hash{$id} };
    
    my $cp = Set::CrossProduct->new( \@data );
    
    my $i = 1;
    while( my $array_ref = $cp->get ) {
        print join( " ", $id, $i++, @$array_ref ), "\n";
    }
}
[download]

ID 1 key2_val1 key1_val1
ID 2 key2_val1 key1_val2
ID 3 key2_val2 key1_val1
ID 4 key2_val2 key1_val2
[download]

Hope this helps,

Chris

Update: You will get huge amount of combinations for 12 rows with 15 items in each array. 15 ^ 12 = 129,746,337,890,625

Yes i think im over estimating my data set. Its more like 15 keys but each key will have 2-3 values. Only one of them has 12 values.

how would CrossProduct deal with arrays that you didnt want to expand? One of the end values might be an array. I would want to copy that as is<\p>

Something like this would prevent one of the arrays from being processed in the cross product.

#!/usr/bin/perl
use strict;
use warnings;
use Set::CrossProduct;

my %hash=('ID' => {
                  'key1' => ['key1_val1', 'key1_val2'],
                  'key2' => ['key2_val1', 'key2_val2'],
                  'key3' => ['one', 'two']
                  }
          );

for my $id (keys %hash) {
    my $key3 = delete $hash{$id}{key3};
    my @data = values %{ $hash{$id} };
    
    my $cp = Set::CrossProduct->new( \@data );
    
    my $i = 1;
    while( my $array_ref = $cp->get ) {
        print join( " ", $id, $i++, @$array_ref ), "\n";
    }
    
    print "@$key3\n";
}
[download]

Prints

ID 1 key2_val1 key1_val1
ID 2 key2_val1 key1_val2
ID 3 key2_val2 key1_val1
ID 4 key2_val2 key1_val2
one two
[download]

Too many nested loops? Sounds like you need recursion!

Ok, i've come across this example of recursion from another user on this forum BrowserUk But i'm having trouble understanding it. Could anyone help?

Re^3: Variable number of foreach loops

The code is below:

#! perl -slw
use strict;

sub nForX(&@) {
    my $code = shift;
    my $n = shift;
    return $code->( @_ ) unless $n;
    for my $i ( @{ shift() } ) {
        &nForX( $code, $n-1, @_, $i );
    }
}

my @a = 1..10;
my @b = 'a'..'z';
my @c = map chr, 33 .. 47;

nForX {
    print join ' ', @_;
} 3, \( @a, @b, @c );
[download]

Anyone? Thanks.

OK, I’ll have a go at explaining how this works. But note first that BrowserUk produced his elegant solution by exploiting some of the less-well-known features of Perl syntax. Let’s get them out of the way first:

Read more... (2 kB)

Now to the recursion. (1) On the first call, $code is initialised to the block { print join ' ', @_; }, and $n is set to 3. As 3 is non-zero, the call to return $code->(@_) is skipped. The for loop which follows is equivalent to this:

for my $i (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
{
    &nForX($code, 2, \@b, \@c, $i);
}
[download]

The first iteration of this loop calls nForX for the second time, as follows:

&nForX($code, 2, \@b, \@c, 1);
[download]

(2) Within this second call, $code is set as before, and $n is 2. The for loop is now equivalent to this:

for my $i ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
+ 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
+)
{
    &nForX($code, 1, \@c, 1, $i);
}
[download]

On its first iteration, it calls nForX for the third time, as follows:

&nForX($code, 1, \@c, 1, 'a');
[download]

(3) Within this third call, $n is 1, and the loop is now this:

for my $i ('!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',',
+ '-', '.', '/')
{
    &nForX($code, 0, 1, 'a', $i);
}
[download]

On its first iteration, this loop calls nForX for the fourth time, as follows:

&nForX($code, 0, 1, 'a', '!');
[download]

(4) Within this fourth call, $n is now zero, so the sub ends with the statement return $code->(@_);, which is here equivalent to:

return print join ' ', 1, 'a', '!';
[download]

So at this point, the first line of output is printed, and a “true” value is returned to the caller, which was the third call to nForX. That third call throws the return value away, and proceeds to the next iteration of its for loop, which is equivalent to this:

&nForX($code, 0, 1, 'a', '"');
[download]

— and so on and so on, until all the calls to nForX have returned and all the loops are exhausted. (As am I, after all that!)

Hope that helps,

Athanasius <°(((>< contra mundum

Iustus alius egestas vitae, eros Piratica,

Any tips on where to start with that? I'm googling recursion but it looks massively complicated.

my %hash=('ID' => {
                  'key1' => [ "key1_val1", "key1_val2" ],
                  'key2' => [ "key2_val1", "key2_val2" ]
                  }
          );

foreach my $id (keys %hash ) {
    foreach my $keyno ( sort keys %{$hash{$id}} ) {
        for (my $keyvalno = 0; $keyvalno <= $#{$hash{$id}{$keyno}}; $k
+eyvalno++) {
            print "$id - $keyno - $hash{$id}{$keyno}[$keyvalno]\n";
        }
    }
}
[download]