use CGI;
@array1 = param('datalist1');
@array2 = param('datalist2');
@array3 = param('datalist3');
[download]

my %data = map { $_ => [param $_] } qw(datalist1 datalist2 datalist3);
[download]

sub compare {
  my @lengths = map { scalar @{$data{$_}} } qw(datalist1 datalist2 dat
+alist3);
  my $first = shift @lengths;
  $first == $_ or return 0 for @lengths;
  return 1;
}
[download]

-- Randal L. Schwartz, Perl hacker

Okay, I cannot resist. This is the product of not enough sleep and I warn all who continue. Given we have used merlyn's suggestion for a hash of arrays ( I was actually thinking of an array of ararys, but why not a hash? ), what if we did something like this

sub compare {
  my %data = @_;
  my @lengths = sort { $a <=> $b } map { scalar@{$data{$_}} } keys %da
+ta;
  return $lengths[0] == $lengths[-1];
}
[download]

Basically, if we sort the lengths and the last element is equal to the first element, then everything else inbetween must be equal.

This has likely no value - it really isn't clearer nor does it likely save any cycles. I just thought it was fun and have not had enough sleep.

UPDATE: did I mention not enough sleep? Fixed a typo
mikfire

I see... thanks. Seem function map is pretty useful.

I too couldn't resist. A single walk through the hash's keys is the fastest way I could think of doing this:

sub dkubb_compare {
  my $data  = shift;
  my $first = @{$data{scalar each %$data}};

  while(my $key = scalar each %$data) {
    return 0 unless $first == @{$data{$key}};
  }

  return 1;
}
[download]

IMHO, it's a little too obscure to be used in production code, but I think it still is a neat idiom.