This could still be inefficient, k could be n^2/2 but still nothing is reported because we only need to report the pairs for which field 1 differs. OTOH, if it's known that if the fields 0, 2, and 3 are equal that then field 1 is different, the algorithm used is optimal:

use strict;
use warnings;

my @AoA;

while (<DATA>) {
    push @AoA => [split];
}

my @sort = sort {$a -> [0] cmp $b -> [0]  ||
                 $a -> [2] <=> $b -> [2]  ||
                 $a -> [3] <=> $b -> [3]} @AoA;

foreach my $i (0 .. $#sort - 1) {
    foreach my $j ($i + 1 .. $#sort) {
        last unless $sort [$i] -> [0] eq $sort [$j] -> [0] &&
                    $sort [$i] -> [2] == $sort [$j] -> [2] &&
                    $sort [$i] -> [3] == $sort [$j] -> [3];
        next if $sort [$i] -> [1] eq $sort [$j] -> [1];
        print "[@{$sort[$i]}] and [@{$sort[$j]}]\n";
    }
}

__DATA__
AAA BUY 98 0
BBB SEL 27 1
FFF BUY 43 4
AAA SEL 98 0
CCC SEL 98 0
[download]

Abigail

my @AoA = (
        [ "AAA", "BUY", "98", "0" ],
        [ "BBB", "SEL", "27", "1" ],
        [ "FFF", "BUY", "43", "4" ],
        [ "AAA", "SEL", "98", "0" ],
        [ "CCC", "SEL", "98", "0" ],
);

use strict;
use warnings;

use Algorithm::Diff qw(diff);
use Data::Dumper;

for (0 .. $#AoA - 1) {
    print Dumper( diff(@AoA[$_, $_ + 1]) );
}
[download]

_________
broquaint

rdfield

my %dups;
$dups{ join('~',@$_[0,2,3]) }{$_->[1]}++ for @AoA;
[download]

for (my $i = 0; $i < @AoA; $i ++) {
  for (my $j = $i+1; $j < @AoA; $j++) {   # start from the following e
+ntry
    my $tmp = join(',', $AoA[$j]);   # join each inner array to a stri
+ng
    if ($AoA[$j] =~ /$AoA[$i][0]\,(\w+)\,$AoA[$i][2]\,$AoA[$i][3]/) {
       # 0, 2 and 3 are equal, check 1
      if (AoA[$i][1] eq $1) {
         # found what we needed, do something
      }
    }
  }
}
[download]

#!/usr/bin/perl -w

use strict;

my %arr;
my @AoA = (
           [ "AAA", "BUY", "98", "0" ],
           [ "BBB", "SEL", "27", "1" ],
           [ "FFF", "BUY", "43", "4" ],
           [ "AAA", "SEL", "98", "0" ],
           [ "CCC", "SEL", "98", "0" ],
    );


#Walk through the array, 
for(my $i = 0; $i < scalar(@AoA); $i++) {
   # hashkey on items 0, 2 and 3.
   my $key = $AoA[$i][0] . $AoA[$i][2] . $AoA[$i][3];
   # store item 1 in a list
   if(defined($arr{$key})) {
      my $lines = $arr{$key};
      push(@$lines, $AoA[$i][1]);
      $arr{$key} = $lines;
   } else {
      my @lists = ($AoA[$i][1]);
      $arr{$key} = \@lists;
   }
}

#print out sames
my @keys = keys %arr;
foreach my $key (@keys) {
   my $options = $arr{$key};
   print join(' ', @$options) . " with this info: $key \n";
}
[download]

I'm sure there are some optimizations that can be made, so if anybody sees anything, I would love to hear feedback. Thanks
--
Ben

#!/usr/bin/perl -w
use strict;
use Data::Dumper;

my @AoA = (
    [ qw(AAA BUY 98 0) ],
    [ qw(BBB SEL 27 1) ],
    [ qw(FFF BUY 43 4) ],
    [ qw(AAA SEL 98 0) ],
    [ qw(CCC SEL 98 0) ],
);

my %directive_for;
push @{ $directive_for{$_->[0]}{$_->[2]}{$_->[3]} }, $_->[1] for @AoA;

my @grouped;
for my $i (keys %directive_for) {
    for my $j (keys %{$directive_for{$i}}) {
        for my $k (keys %{$directive_for{$i}{$j}}) {
            push @grouped, [ $i, $directive_for{$i}{$j}{$k}, $j, $k ];
        }
    }
}

print Dumper(\@grouped);
[download]

Makeshifts last the longest.

Much appreciation for All of your Help. I have a solution that works now and several others to learn a lot from. Thanks!!!