Sounds like the typical impossible "I want to do iterative task X without iterating" request. Use List::Util and map and you can hide most of it, though.

use List::Util qw( sum );
use YAML::Syck qw( Load );

my $hash = Load( do { local $/; <DATA> } );
my $count = sum( map { scalar @{ $hash->{ $_ } } } keys %${hash} );

print $count, "\n";

__END__
foo:
  - A
  - B
  - C
bar:
  - D
  - E
baz:
  - F
  - G
  - H
[download]

Addendum: Just to make things clear: as others have below I'm interpreting "a total count of elements in a Hash of Arrays" to mean "a sum of the count of elements in each arrayref contained in a hash". And just to add more "twaddle", a Ruby version:

require 'yaml'
hash = YAML::load( <<EOT )
foo:
  - A
  - B
  - C
bar:
  - D
  - E
baz:
  - F
  - G
  - H
EOT

count = hash.values.inject(0) { |s,a| s += a.size }
puts count

## O(1) version, akin to ikegami's below
o_1_count = 0
hash.each_value { |a| o_1_count += a.size }

## Duuurh, Hash isa Enumerable so it has an inject itself
or_even_count = hash.inject( 0 ) { | s, (k,v) | s += v.size }
[download]

Addendum Update: Changed Ruby version to use hash.values rather than hash.keys, as seen below, which is actually a cleaner implementation than mine above. Also added (what should be :) an O(1) Ruby implementation. And also added using Hash#inject directly rather than iterating over values.

should do it

No, it shouldn't. @{...} expects that ... retunrns a reference to an array. values %hash does not.

anyway short of iterating through the entire hash.

What do you think values does? Returns a list obtained by iterating through the entire hash.

And whatever processes the list returned by value has to iterate over that list.

These work:

# time = O(N)   memory = O(N*M)

my $count = map @$_, values %h;
[download]

# time = O(N)   memory = O(N)

my $count = sum map { scalar @$_ } values %h;
[download]

# time = O(N)   memory = O(N)

my $count = 0;
$count += @$_ for values %h;
[download]

# time = O(N)   memory = O(1)

my $count = 0;
while (my ($k, $v) = each(%h)) {
   $count += @$v;
}
[download]

Update:
Added 2nd and 4th solution.
Added time and memory analysis.
Choose the one that's the most readable and maintainable within your speed and memory requirements.

Though I would not recomend using the second on big datastructures as it builds a list of all the elements in the arrays in the hash. Use either the first solution or

use List::Util qw(sum);

my $count = sum map scalar(@$_), values %h;

#or
# my $count = sum( map scalar(@$_), values(%h));
# or
# my $count = sum( map {scalar(@$_)} values(%h));
# if that syntax looks more readable to you.
[download]

Regarding the update: the first solution uses O(N) of memory where N is the number of elements of the hash, the second O(N*M) where M is the average length of the array in the hash. The List::Util solution is also O(N) memorywise.

Jenda


Support Denmark! Defend the free world!

This is wrong. There is absolutely no reason to iterate the hash to count the elements!

c:\test>p1
Perl> %a = 'a' ..'z';;
Perl> print scalar values %a;;
13
[0] Perl> print scalar keys %a;;
13
[download]

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

He asked for the number of elements in the HoA. I took that to mean 5 for the following structure:

my %h = (
   k1 => [ qw( a b c ) ],
   k2 => [ qw( d e ) ],
);
[download]

Your solution simply returns the number of elements in a hash. It could be that's what he meant, but that's now how I interpreted his question.

This is wrong.

Not so hasty on the wrong. Fletch and Jenda also interpreted the question like I did.

Just

my $count = values %hash;
[download]

would do it. Both keys and values return the respective counts when called in a scalar context.