You create a hash with all elements of array2 as the keys. When iterating through array1, you check whether the elements exists in the hash.

my %match;
undef @match{ @array2 };
for (@array1) {
  print "$_",exists $match{$_}?" match":"","\n";
}
[download]

Or just use Perl's 'smart' operator (no hash needed):

print $_ ~~ @array2 ? "$_: Match!\n" : "$_: No Match\n" for @array1;
[download]

Much better...

Consider using the Module List::Compare to obtain the two lists' intersection, then place that intersection into a hash. When you iterate through the first array, check whether there's a key for each element of that array. If there's a key, it's a common element, so 'highlight' it, else leave it 'unhighlighted.'

Hope this helps!

First method (non-Perl):

1. sort fileA and write it to /tmp
2. sort fileB and write it to /tmp
3. Use cmp or diff to detect the differences between the two /tmp files and report.

1. read fileA and use each value as a hash-key with a hash-value of 1 ($seen_hash{$valueA} = 1;)
2. read fileB and use each value as a hash-key and add a value of 2 ($seen_hash{$valueB} += 2;)
3. Read through the hash and report on all keys where the value is '3'.

What happens if there are duplicates in fileB?

Here's my offering:

1. Stringify and hashify the smaller array (set the value to '1' for each key)
2. Iterate through the stringified keys of the larger array, doing an exists() for each value to see if it exists in the smaller array
3. If it exists, print "Matches'"
4. If it doesn't, print "Doesn't match"

Frankly, I do not see why using an %already_seen hash would be more complicated than a grep on the content of the smaller file. Actually, when I started to learn Perl about 10 years ago, it took me just a few days to be able to set up a solution with a hash for this type of problem, I learned to use the grep function only a number of months later.

Using a hash is also algorithmically much more intellectually satisfying. Granted, with about 1,000 records, it does not make much of a difference, and, to tell the truth, I am also sometimes lazy. I just found today a piece of code (not in Perl, in a programming language having no built-in sort function) that I wrote less than a year ago in which I developed a simple 5-line bubble sort, despite its known inefficiencies, just because I knew that my lists to be sorted would usually have an average 2 to 3 elements and never more than 6. Worse than that, in that same language that I mentioned, I am regularly using a goto instruction, because it is in my experience the best way to exit forward of a code block when looping on the records of a database (I am using it exclusively as an equivalent of the next instruction in a Perl loop). I am mentioning these things just to show that I am really not a CS purist or bigot, I also like to keep things simple when there is no point of making them complicated. In the case in point, however, the idea of visiting 1882 times 1042 records when you can do it only once (or twice, depending on what you count) at no cost in terms of code simplicity with a hash really goes against every tenet that I have learned over my past 30 years of programming experience.

Thirty years ago, the difference might have mattered.

Thirty differences ago, the years might have mattered.

perl -e 'my @bigArray=1..1883; my @smallArray=1..1043; $_~~@smallArray
+?print "Matches=>$_\n":print "$_\n" foreach(@bigArray);'
[download]