G'day Eily,

++ I tried a few things independently; however, it appears that much of that is very similar to what you've done, so I'll post it here for comparison.

"my @keys = keys %$hash_ref;" was one of my first thoughts and this appeared to be a definite winner. I also tried inlining the results (now discarded, but it was something like: "sub hrkeys () { keys %$hash_ref }"): that proved to be slower than using "@keys".

I had code very similar to your "sum map ..."; although, I used sum0. That appeared to be slower (even with the "map EXPR" form I used); I suspect any gains from sum were overshadowed by losses from map; I didn't investigate that any further.

I didn't think of caching. That's a good idea, and might put "sum(0) map" back in the picture; however, as you stated, that will depend on the OP's data (which hasn't been shown).

I dummied up some test data (based on the OP's description but, I'm sure, far from representative); ran some basic timings; and included some sanity checking. Here's the code I found to be fastest.

#!/usr/bin/env perl -l

use strict;
use warnings;

use Time::HiRes 'time';

my $hash_ref;
@$hash_ref{'a' .. 'j'} = 1 .. 10;
my $array_ref = [ ('v-w-x-y-z') x 2e6 ];
my $foo;
my $value = 0;
for my $outer ('v' .. 'z') {
    $foo->{$outer}{$_}{value} = ++$value for 'a' .. 'j';
}

my $t0 = time;
op_code();
my $t1 = time;
printf "op_code:   %.6f\n", $t1 - $t0;
kens_code();
my $t2 = time;
printf "kens_code: %.6f\n", $t2 - $t1;
print '*** Compare ***';
printf "kens/op:   %.6f%%\n", (($t2 - $t1) / ($t1 - $t0)) * 100;

sub op_code {
    my $bar;

    foreach my $a (@{ $array_ref }) {
        my $i = 0;
        foreach my $b (split('-', $a)) {
            foreach my $c (keys %{ $hash_ref }) {
                $i += $foo->{$b}->{$c}->{'value'};
            }
        }
        push @{ $bar->{$i} }, $a;
    }

    print '*** op_code ***';
    print "@{[ $_, $#{$bar->{$_}}, $bar->{$_}[0] ]}" for keys %$bar;
}

sub kens_code {
    my $bar;
    my @keys = keys %$hash_ref;

    for my $outer (@$array_ref) {
        my $sum;
        for my $inner (split /-/, $outer) {
            for (@keys) {
                $sum += $foo->{$inner}{$_}{value};
            }
        }
        push @{$bar->{$sum}}, $outer;
    }

    print '*** kens_code ***';
    print "@{[ $_, $#{$bar->{$_}}, $bar->{$_}[0] ]}" for keys %$bar;
}
[download]

The array, with two million elements, took about 30s (so it's roughly comparable to what the OP describes). My code was typically shaving around 25-30% off of this. I ran it quite a few times — here's a fairly representative run.

*** op_code ***
1275 1999999 v-w-x-y-z
op_code:   31.985272
*** kens_code ***
1275 1999999 v-w-x-y-z
kens_code: 23.075756
*** Compare ***
kens/op:   72.144941%
[download]

By the way, I totally agree with your comments re $a and $b: I only use those as special variables. I'm not completely averse to single-letter variable names, such as $i for a loop index; although, I do cringe when I find them liberally scattered through production code — meaningful names are a much better choice.