Print all possible combinations of an array of arrays - arrays

Question

I want to take three files that each contain 80 or more lines of text and print all possible combinations of those three files.
For the sake of clarity, let's assume that
File1 contains
1
2
3
File2 contains
4
5
6
File3 contains
7
8
9
If I wanted to print only those combinations then there are many answers that I could use. However, as the files contain more lines that I care type manually into the Perl script. I am building an array from each file, then I build an array ref of those arrays. Finally I am attempting to use List::Permutor to print the combinations.
The problem I am getting is that I am printing out the memory references, and I cannot figure out how to dereference the arrays inside of the List::Permutor call.
Perl code
use List::Permutor;
use warnings;
open (FILE, app_txt);
chomp (#app = (<FILE>));
close (FILE);
open (FILE, att1_txt);
chomp (#att1 = (<FILE>));
close (FILE);
open (FILE, att2_txt);
chomp (#att2 = (<FILE>));
close (FILE);
my $permutor = List::Permutor->new( \#app, \#att1, \#att2);
while ( my #permutation = $permutor->next() ) {
print "#permutation\n";
}

Answer 1

I wrote Set::CrossProduct for this purpose.

Answer 2

It's not clear what you want.
Note that all the provided output of the snippets below are for the following inputs:
my #app = ( 1, 2, 3 );
my #att1 = ( 4, 5, 6 );
my #att2 = ( 7, 8, 9 );
If you want permutations of the arrays, your code works as-is.
use List::Permutor qw( );
my $permutor = List::Permutor->new( \#app, \#att1, \#att2);
while ( my #permutation = $permutor->next() ) {
say join ", ", map { "[#$_]" } #permutation;
}
Output:
[1 2 3], [4 5 6], [7 8 9]
[1 2 3], [7 8 9], [4 5 6]
[4 5 6], [1 2 3], [7 8 9]
[4 5 6], [7 8 9], [1 2 3]
[7 8 9], [1 2 3], [4 5 6]
[7 8 9], [4 5 6], [1 2 3]
If you want permutations of the contents of the arrays (regardless of the array from which a string originated), then you just need to create a list from the contents of the arrays.
use List::Permutor qw( );
my $permutor = List::Permutor->new( #app, #att1, #att2 );
while ( my #permutation = $permutor->next() ) {
say "#permutation";
}
Output:
1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 9 8
1 2 3 4 5 6 8 7 9
1 2 3 4 5 6 8 9 7
1 2 3 4 5 6 9 7 8
1 2 3 4 5 6 9 8 7
1 2 3 4 5 7 6 8 9
1 2 3 4 5 7 6 9 8
1 2 3 4 5 7 8 6 9
1 2 3 4 5 7 8 9 6
...
9 8 7 6 5 4 3 2 1
Keep in mind that P(80) is 100,000,000,000,000,000,000,000,000,000,000,000,000 times the number of atoms in the observable universe.
If you want all possible sets of a single element from each array, then you can use the following:
for my $app (#app) {
for my $att1 (#att1) {
for my $att2 (#att2) {
say "$app $att1 $att2";
}}}
or
use Algorithm::Loops qw( NestedLoops );
my $iter = NestedLoops([ \#app, \#att1, \#att2 ]);
while ( my ($app, $att1, $att2) = $iter->() ) {
say "$app $att1 $att2";
}
Output:
1 4 7
1 4 8
1 4 9
1 5 7
1 5 8
1 5 9
1 6 7
1 6 8
1 6 9
2 4 7
...
3 6 9

Answer 3

I solved my last issue with formatting, by cheating. I just edited the source files and removed all the \r and \n.
Final code:
use Algorithm::Loops qw( NestedLoops );
use warnings;
open (FILE, app_txt);
($app = (<FILE>));
close (FILE);
my #app = split /,/, $app;
open (FILE, att1_txt);
($att1 = (<FILE>));
close (FILE);
my #att1 = split /,/, $att1;
open (FILE, att2_txt);
($att2 = (<FILE>));
close (FILE);
my #att2= split /,/, $att2;
my $iter = NestedLoops([ \#app, \#att1, \#att2 ]);
while ( my ($app, $att1, $att2) = $iter->() ) {
open (my $fh, '>', 'test');
print $fh "$app $att1 $att2\n";
close $fh;
}
print "done\n";