If the idea is to find the common elements, with case insensitivity, then you can use hashes. Let the keys be uppercased for all entries, and the values be the originals. Then you can use standard techniques for set comparison using hashes.

my %a = map {( uc($_) => $_ )} @a;
my %b = map {( uc($_) => $_ )} @b;

my @common_keys = grep { exists $a{$_} } keys %b;

my @a_values_seen_in_b = @a{ @common_keys };

my @b_values_seen_in_a = @b{ @common_keys };
[download]

There are also modules on CPAN for tied hashes which allow you to store and retrieve keys case-insensitively; but I don't think they're necessary for this problem.

You want to make sure that the whole string matches and not just a substring. You can use the "anchors" ^ (start of string) and $ (end of string) for that:

if($a[$i] =~ /^$b[$j]$/i)
[download]

But if you want to compare the whole string, a direct comparison of the upper case variants is more straightforward:

if(uc $a[$i] eq uc $b[$j]) {
...
}
[download]

Does @b contain regexp or strings? If it contains regexps, your second snippet doesn't work. If it contains strings, your first snippet is broken. Sounds like @b contains strings, so the solutions would be

if ($a[$i] =~ /^\Q$b[$j]\E\z/i)
[download]

and (the much faster)

if (uc $a[$i] eq uc $b[$j])
[download]

You can only omit the quoting provided by \Q...\E is you are sure @b doesn't contains any meta characters.

Read more... If @b contains regexps (302 Bytes)

#!/usr/local/bin/perl -slw
use strict;

use Benchmark qw[ cmpthese ];

our  @a = qw/AA12 BB13 CC14 DD15/;
our  @b = qw/aa1 aa2 aa12 bb13/;

sub regex {
  my @match;
  for my $i ( 0 .. $#a ) {
    for my $j ( 0 .. $#b ) {
      if ( $a[$i] =~ m/^$b[$j]$/i ) {
        push @match, "$i -> $j";
      }
    }
  }
  return @match;
}

sub lccmp {
  my @match;
  for my $i ( 0 .. $#a ) {
    for my $j ( 0 .. $#b ) {
      if ( lc($a[$i]) eq lc($b[$j]) ) {
        push @match, "$i -> $j";
      }
    }
  }
  return @match;
}

cmpthese -1, {
    lccmp  => q[ lccmp() ],
    regex  => q[ regex() ],
};
[download]

         Rate regex lccmp
regex  8083/s    --  -82%
lccmp 45997/s  469%    --
[download]

use List::Compare;
@a = qw/AA12 BB13 CC14 DD15/;
@b = qw/AA1 AA2 AA12 BB13/;

    $element = List::Compare->new(\@a, \@b);
    #@UF = $element->get_unique;
    @CB = $element->get_intersection;

print join "\n", @CB;
[download]

    @union = @intersection = @difference = ();
    %count = ();
        foreach $element (@a, @b) { $count{$element}++ }
        foreach $element (keys %count) {
        push @union, $element;
        push @{ $count{$element} > 1 ? \@intersection : \@difference }
+, $element;
        }

    foreach $int (@difference){
        if ($int ne " "){
            @fname = split(/ /, $int);
            print "\n difference elements --> $fname[0]\n";
        }
    }
[download]

Edited by planetscape - added code tags

thanks, monks ^^
although some of your suggestions
are above my level
I'll work hard to keep up with it

Hi tanyeun, Here is a simple way to compare your arrays.

my @arr1= sort (@$a); my @arr2= sort (@$b);
    for my $x (0..$#b)
    {
        if ($b[$x] ne $a[$x])
        {
        print ("Mismatch in $arr1[$x]");
        }
    }

Here, I am sorting both the arrays, then using a for loop to run the execution the number of times till all the elements are encountered. Then I am using a if condition to check whether each and every element in the array matches with its corresponding element in the second array. If needed, you can also add the following codes before the above lines

if ($#arr1 != $#arr2)
{
print "count of elements in two arrays do not match";
exit;
}

With this, I am ensuring the number of elements in array 'a' matches with the number of elements in array 'b' before the actual one-to-one match is made.

Also consider having a smart solution!!! Use Array::Compare. Hope this helps