my @keys = sort {
    my @a = split '-', $tapes{$a};
    my @b = split '-', $tapes{$b};
    $a[-1] cmp $b[-1]
} keys %tapes;
foreach my $k (@keys) {
    print "$k $tapes{$k}\n";
}
[download]

However, I wouldn't put that code into production without understanding what it does. I urge you to ask questions, which I'll gladly answer.

Update:Fixed keys/values conflation.

This sorts based on keys instead of values, no need to use split commands as the keys do not contain any dashes.

If you had to sort only based upon the keys, you'd write something like this:

for my $k (sort keys %hash) {
   print "$k $hash{$k}\n";
}
[download]

my @ordered_keys = sort { order($hash{$a}, $hash{$b}) } keys %hash;
for my $k ( @ordered_keys ) {
   print "$k $hash{$k}\n"
}

sub order {
   my ($left, $right) = @_;
   # Perform comparison between $left and $right. Return
   # -1 if $left must come *before* $right, 0 if they are
   # equivalent, +1 if $left must come *after* $right
}
[download]

The actual implementation of the order() subroutine is left as exercise, but you could extract the last two characters from $left and $right, and use the cmp operator :)

You could just do my @ordered_keys = sort { substr($tapes{$a},-2) cmp $substr($tapes{$b},-2) } keys %tapes;

foreach my $key (sort { substr($hash{$a}, -2) cmp substr($hash{$b}, -2
+) } keys %hash) {
   print $key . ' ' . $hash{$key} . "\n";
}
[download]

sub sieve {
  my @pats = UNIVERSAL::isa($_[0], 'Regexp') ? @_ : map(qr/$_/, @_);

  sub {
    my %slots;
    $slots{$_} = [] for @pats, "";

    my $cref = UNIVERSAL::isa($_[0], 'CODE') && shift;

    ITEM:
    for (@_) {
      my $k = $cref ? $cref->() : $_;
      for my $p (@pats) {
        push(@{ $slots{$p} }, $_), next ITEM if $k =~ /$p/;
      }
      push @{ $slots{""} }, $_;
    }

    return map @$_, @slots{@pats, ""};
  }
}


my %tapes = (...);
my $c5p5 = sieve(qr/-C5$/, qr/-P5$/);
my @sorted_keys = $c5p5->(sub { $tapes{$_} }, keys %tapes);
[download]

P.S. this looks much prettier in Ruby.

You can also use a sieve. It's potentially faster than a complicated sort() algorithm to place things matching certain patterns before others.

The code you post maybe faster than a 'sort', but compared to your "sieve", the sort needed is very simple.

I fail to understand the reason of this awfully complicated code. For this case, I'd just iterate over the hash twice:

my ($k, $v);
$v =~ /C5$/ and print "$k $v\n" while ($k, $v) = each %tapes;
$v =~ /P5$/ and print "$k $v\n" while ($k, $v) = each %tapes;
[download]

If you want to iterate once, you need additional storage:

my (@C5, @P5);
while (my ($k, $v) = each %tapes) {
    $v =~ /C5$/ ? push @C5, "$k $v\n" 
                : push @P5, "$k $v\n";
}
print @C5, @P5;
[download]

Although you can reduce storage costs by printing the first set while iterating:

my @P5;
while (my ($k, $v) = each %tapes) {
    $v =~ /C5$/ ? print "$k $v\n" : push @P5, "$k $v\n";
}
print @P5;
[download]

Perl --((8:>*

The more cases you have, the less efficient it is to loop over the data set each time. That's where a sieve comes in handy. It short-circuits the loop over the filters, and loops through the data only once.

---

Jeff japhy Pinyan, P.L., P.M., P.O.D, X.S.: Perl, regex, and perl hacker
How can we ever be the sold short or the cheated, we who for every service have long ago been overpaid? ~~ Meister Eckhart