in reply to Efficiently sorting array by non-alpha strings

knowmad,
I am assuming you want to sort first by locality type and second by title ASCIIBetically. 
#!/usr/bin/perl
use strict;
use warnings;
my @advocates = (
  {fld_title => 'Rec1', fld_type => 'National'},
  {fld_title => 'Rec2', fld_type => 'State'   },
  {fld_title => 'Rec3', fld_type => 'Local'   }
);
my %order =  (LOCAL => 'A', STATE => 'B', NATIONAL => 'C');
my @sorted = map { $_->[0] }
            sort { $a->[1] cmp $b->[1]
                          ||
                   $a->[2] cmp $b->[2] }
            map { [ $_ , $order{uc $_->{fld_type}}, $_->{fld_title} ] 
+} @advocates;

[download]
Cheers - L~R

I am waiting for tye to comment on my persistent use of the ST.

Replies are listed 'Best First'.
Re: Re: Efficiently sorting array by non-alpha strings
by knowmad (Monk) on Feb 20, 2004 at 16:21 UTC

    L~R,

    I had not considered the secondary sort by title. Nice touch!

    I added your example into my benchmark tests which now include my original hack, Abigail's bucketsort example and yours (which looks to me like a Schwarztian Transform, no?). Yours takes the cake:

    Benchmark: timing 500000 iterations of bucketsort, sort, st...
bucketsort:  1 wallclock secs ( 1.73 usr +  0.00 sys =  1.73 CPU) @ 28
+9017.34/s (n=500000)
      sort:  1 wallclock secs ( 0.90 usr +  0.00 sys =  0.90 CPU) @ 55
+5555.56/s (n=500000)
        st:  0 wallclock secs ( 0.66 usr +  0.00 sys =  0.66 CPU) @ 75
+7575.76/s (n=500000)
               Rate bucketsort       sort         st
bucketsort 289017/s         --       -48%       -62%
sort       555556/s        92%         --       -27%
st         757576/s       162%        36%         --

    [download]

    Thanks,

    -Wm
[reply]
[d/l]
      knowmad,
      Actually, you can avoid the ST all together, which should be even faster. 
      #!/usr/bin/perl
use strict;
use warnings;
my @advocates = (
  {fld_title => 'Rec1', fld_type => 'National'},
  {fld_title => 'Rec2', fld_type => 'State'   },
  {fld_title => 'Rec3', fld_type => 'Local'   }
);
my %order =  (LOCAL => 'A', STATE => 'B', NATIONAL => 'C');
my @sorted = sort { $order{uc $a->{fld_type}} cmp $order{uc $b->{fld_t
+ype}}
                          ||
                   $a->{fld_title} cmp $b->{fld_title} } @advocates;

print "$_->{fld_title}\n" for @sorted;

      [download]
      Cheers - L~R
[reply]
[d/l]
        It's even faster if you avoid the sort block, using GRT: 
        #!/usr/bin/perl

use strict;
use warnings;

use Benchmark qw /timethese cmpthese/;

our @advocates = map {{fld_title => 'Rec' . $_,
                       fld_type  => [qw /National State Local/] -> [ra
+nd 3]}}
                     1 .. shift || 1000;


our %order   = (LOCAL => 'A', STATE => 'B', NATIONAL => 'C');
our %order_r = reverse %order;

our (@limbic, @GRT);

cmpthese -1  => {
    limbic   => '@limbic = sort {$order {uc $a -> {fld_type}} cmp
                                 $order {uc $b -> {fld_type}} or
                                 $a -> {fld_title} cmp $b -> {fld_titl
+e}}
                           @advocates',
    GRT      => '@GRT = map {{fld_title => substr ($_, 1),
                              fld_type  => $order_r {substr $_, 0, 1}}
+}
                        sort
                        map {join "", $order {uc $_ -> {fld_type}},
                                                 $_ -> {fld_title}} @a
+dvocates',
};
                       
                     
my $limbic = join " " => map {$_ -> {fld_title}} @limbic;
my $GRT    = join " " => map {$_ -> {fld_title}} @GRT;

die "Unequal\n" unless $limbic eq $GRT;
__END__
         Rate limbic    GRT
limbic 61.9/s     --   -49%
GRT     121/s    95%     --

        [download]
        It does lose the case of fld_type, but that's easily fixable.

        Abigail

[reply]
[d/l]

In Section Seekers of Perl Wisdom