There are some efficincies to be had in the general approach. It is unclear if you want [ [1], [2] ] to be equal to [ [1,2] ]. Regardless the earlier you can fail the better for speed:

my $ha = [[1,2],
       [5,5,5],
       [1,2,],
       [3,4]];

my $hb = [[4,3],
       [1,2],
       [2,1,1],
       [5,5,5]];
      
# flatten
my @ha = map{ @$_ } @$ha;
my @hb = map{ @$_ } @$hb;

# fail immediately unless equal num elements.
if ( @ha != @hb ) { 
    print "Not equal num items!\n";
}
else {
     # now no choice but to sort or do detail compare
     if ( (join ' ', sort @ha) eq (join ' ', sort @hb) ) {  print "Equ
+al\n" }
     else { print "Not equal\n" }
}
[download]

It is possible to use a hash to avoid the sort, even with duplicate values simply by counting occurences as implemented by BrowserUk

Your idea of sorting first and then comparing is exactly right. There may be a cleverer way, but I don't know what it might be.

Your "serialization" hack is probably not satisfactory. You will need iterative sort and comparison for this to work for arbitrary nested arrays. Recursion is an attractive way of writing that for not-too-deep nesting.

Like this:

    sub serialize {
        my $r = shift;
        ref $r ? '(' . join( ',', sort map serialize($_), @$r ) . ')' 
+: $r
    }

    sub deep_eq {
        my( $x, $y ) = @_;
        serialize($x) eq serialize($y)
    }
[download]

jdporter
The 6th Rule of Perl Club is -- There is no Rule #6.

Update: I misread your post. Sorry.

This might be a little quicker as it avoids the sorting

#! perl -slw
use strict;

sub cmpAoAs{
    my( $a, $b ) = @_;
    my %h;
    $h{ $_ }++ for map{ @$_ } @$a;
    $h{ $_ }-- for map{ @$_ } @$b;
    return 0 == grep{ $_ } values %h;
}

my $ha = [ [1,2], [5,5,5], [1,2], [3,4] ];
my $hb = [ [4,3], [1,2], [2,1], [5,5,5] ];

print 'Same' if cmpAoAs $ha, $hb;
__END__
P:\test>342841
Same
[download]

However, on the surface of what you've told us, it loooks a little like your using the wrong structure if only the presence and count of a value (rather than it's position) determine equivalence. But I realise that I am not party to the full sp on your application:)

I don't think

my $ha = [ [1,2], [5,5,5], [1,2], [3,4] ];
my $hb = [ [1,3], [5,5,5], [1,2], [2,4] ];
[download]

are supposed to compare equal, as your function will return.

After Compline,
Zaxo

Your solution seems flawed to me: consider


my $ha = [ [1,2], [5,5,5], [1,2], [3,4] ];
my $hb = [ [4,3], [1,2], [2,1,5], [5,5] ];
[download]

These are clearly different, but your code still outputs "same" since it is discarding the entire original structure (and not only the order of elements).

use strict;
my $ha = [[1,2],
         [5,5,5],
         [1,2],
         [3,4]];

my $hb = [[4,3],
         [2,1],
         [1,2],
         [5,5,5]];

sub test
{
    my ($ha, $hb) = @_;
    
    my ($tha,$thb) =  ([],[]);
    
    for( @{ $ha } )
    {
        push @{$tha},[ sort @{$_} ];
    }
    
    $tha = [ sort { $a->[0] <=> $b->[0] } @{$tha} ];
    
    for( @{ $hb } )
    {
        push @{$thb},[ sort @{$_} ];
    }
    
    $thb = [ sort { $a->[0] <=> $b->[0] } @{$thb} ];
    
    use Data::Dumper;
    
    return Dumper($tha) eq Dumper($thb);
}

print test($ha,$hb);
[download]

use strict;
use warnings;

#my $ha = [[1,2], [5,5,5], [1,2], [3,4]];
#my $hb = [[4,3], [1,2], [2,1], [5,5,5]];

my $ha = [ [1,2], [5,5,5], [1,2], [3,4] ];
my $hb = [ [1,3], [5,5,5], [1,2], [2,4] ];

if (cmpAoA($ha,$hb)) { 
  print "THEY ARE THE SAME\n"; 
}
else { 
  print "THEY ARE THE DIFFERENT\n"; 
}

sub cmpAoA {
  my @AoA = @_;
  
  return 0 if @{$AoA[0]} != @{$AoA[1]};

  my %hash; 
  foreach ( @{$AoA[0]} ) { $hash{ stringify($_) }++; }
  foreach ( @{$AoA[1]} ) { $hash{ stringify($_) }--; }
  return 0 == grep { $_ } values %hash;
}

sub stringify {
 return "[" . 
   join(",", 
      map{qq("$_")} 
      sort { $a <=> $b } @$_  
   ). "]"; 
};
[download]

-enlil

Better late than never! Test::Deep might be somewhat overkill but it certainly does the job

use Test::Deep;

my $ha = bag(
  bag(1,2),  
  bag(5,5,5),
  bag(1,2),  
  bag(3,4)
);

my $hb = [
  [4,3],  
  [1,2],
  [2,1], 
  [5,5,5]
];

print eq_deeply($hb, $ha) ? "same\n" : "different\n";
[download]

package Comparator;

sub new { bless $_[1], $_[0] }
sub comparator {
    # Some stuff here
}
[download]

Of course, the interesting bit is the # Some stuff here, and I'll look at implementing it later. Right now, I have interesting stuff to do and it's actually work-related! :-)