Short answer? Make a hash.

perlfaq4 doesn't seem to cover your situation (where the arrays have duplicate values).

First, the code:

my @A = (1,2,3,4,5,4,3,2,1,2);
my @B = (2,4,6,8,10,8,6,4,2);
my (%First, %Second);

push @{ $First{  $A[$_] } }, $_ for (0..$#A);
push @{ $Second{ $B[$_] } }, $_ for (0..$#B);

my %Pairs;
for my $Common (grep {exists $Second{$_}} keys %First){
  for my $Idx (@{ $First{$Common} }){
    push @{ $Pairs{$Common} }, map([$Idx, $_], @{ $Second{$Common} });
  }
}

# Print out what we found
for (sort keys %Pairs){
  print "$_:\n", map("  $_\n", map(join('-', @$_), @{ $Pairs{$_} })), 
+"\n";
}
[download]

After some sample data (@A and @B), we store each array's values in a hash tying those values to their indices in the array.

push @{ $First{  $A[$_] } }, $_ for (0..$#A);
push @{ $Second{ $B[$_] } }, $_ for (0..$#B);
[download]

Now, we loop through all values common to both @A and @B:

  for my $Common (grep {exists $Second{$_}} keys %First){
[download]

  for my $Idx (@{ $First{$Common} }){
    push @{ $Pairs{$Common} }, map([$Idx, $_], @{ $Second{$Common} });
  }
[download]

When finished, %Pairs looks like this (pseudo-code, of course):

  $Pairs{Each Common Value} = [ [A1, B1], [A1, B2], [A2, B1], [A2, B2]
+ ]
[download]

  $Pairs{4} = [[3,1], [3,7], [5,1], [5,7]]
[download]

Since I tried to do everything else in one line, I next print out the contents of %Pairs. The output is:

2:
  1-0
  1-8
  7-0
  7-8
  9-0
  9-8
  
4:
  3-1
  3-7
  5-1
  5-7
[download]

Russ

Russ, thanks for your incredibly detailed response to my question. I am currently studying it as if it were the Bible. I was intrigued by the syntax: push @{ $First{ $A$_ } }, $_ for (0..$#A); I understand what this statement does, but not why it works. P. 259 of the Camel book says that "The argument to push must be a real array, not just a reference to an array." So far so good. It looks as if the syntax creates an anonymous array whose elements are the values of %First. But I see a problem. It says on page 531 of the Camel book that "Hash values do not spring into existence upon reference." So it seems to me that we have a deadlock here. Push demands a value of %First, but %First can only get its values from Push. It seems to me that at the first iteration the command is equivalent to: push @{$First{1}},0; But this ought to fail because at the time of the first iteration $First{1} does not exist. Can anyone explain?

That's not exactly what it does. It's functionally the programmatic reverse of the array: push @{ $First{  $A[$_] } }, $_ for (0..$#A); Let's take it from the inside out:

$A[$_]        -- the element of @A at the current index
$First{ $A[$_] }    -- the previous line is a key in %First
@{ }            -- and the associated value is an anonymous array
[download]

So what the code does is, loop over the number of elements of @A. (If it has ten, the loop goes from 0 to 9). For each of those indices, the value at that index becomes a key in %First, and the value is the element's index, stored in an anonymous array. We have something like this:

Elements of @A:
0    zero
1    one
2    two

Elements of %First:
zero    [ 0 ]
one    [ 1 ]
two    [ 2 ]
[download]

While we can look something up in @A by its index, we can look up the index in %First if we know the something.

Oh, and in Perl hashes have something called auto-vivification. If you access a hash key that doesn't exist (and try to put data there), the key will be created. (Useful, once you get used to it.)

Hi,

Thank you for your kind words. I'm sure my writing falls far short of canonization potential, but I'm flattered nonetheless. :-)

chromatic has a great answer to your question. The quality and helpfulness of the people here at Perl Monks is a constant source of amazement for me. As he describes, I am utilizing auto-vivification in that terse burst of code to reverse the array's indices and values.

To find a value in an array, you must know its index. We build the hash to be able to find the indices when we know the value. All that punctuation lets us define and assign to the hash entry at once.

Good luck.

Russ