%hash = (
    key1 => 10,
    # ...
);
[download]

To count numbers of occurrences, hashes are usually used:

my %freq;
my ($max_freq, $max_value) = 0;
for my $value (values %hash) {
    $freq{$value}++;
    if ($freq{$value} > $max_freq) {
        $max_freq  = $freq{$value};
        $max_value = $value;
    }
}
print "$max_value: $max_freq times\n";
[download]

  DB<100> %hash = (
                key1 => 10,
                key2 => 10,
                key3 => 3,
                key4 => 5,
                key5 => 10
           );
 => ("key1", 10, "key2", 10, "key3", 3, "key4", 5, "key5", 10)

  DB<101> $count{$_}++ for values %hash 
 => ""

  DB<102> \%count
 => { 3 => 1, 5 => 1, 10 => 3 }

  DB<106> ($max) = reverse sort values %count
 => 3

  DB<109> grep { $count{$_} == $max } %count
 => 10
[download]

this will give you a list of all values which are maximal, not only one.

update

otherwise, if only one value is enough:

  DB<119> %rcount= reverse %count
 => (3, 10, 3, 10)

  DB<120> \%rcount 
 => { 1 => 3, 3 => 10 }

  DB<121> $rcount{$max}
 => 10
[download]

and here an easier approach to find the maxmimum.

  DB<113> use List::Util qw/max/

  DB<114> $max = max values  %count
 => 3
[download]

phildeman:

I like to invert the hash for things like this. This way, you get a list of the keys for each value:

$ cat t.pl
#!/usr/bin/perl

my %hash = (key1=>10,key2=>10,key3=>3,key4=>5,key5=>10);

my %invhash;
while (my ($k,$v) = each %hash) {
    push @{$invhash{$v}}, $k;
}

for my $v (sort {$a<=>$b} keys %invhash) {
    print "$v cnt=", scalar(@{$invhash{$v}}), 
          " keys=",join(", ",@{$invhash{$v}}), "\n";
}

$ perl t.pl
3 cnt=1 keys=key3
5 cnt=1 keys=key4
10 cnt=3 keys=key5, key2, key1
[download]

But if you don't find the list of keys useful, or if there's too much data, just incrementing a counter as you suggest will do the job.

...roboticus

When your only tool is a hammer, all problems look like your thumb.

#!usr/bin/perl -w
use strict;
#http://perlmonks.org/?node_id=1055552

my %hash = 
(
  key1 => 10,
  key3 => 3,
  key2 => 10,
  key4 => 5,
  key5 => 10,
  key6 => 3,
);

# The keys don't matter.
# What matters is the histogram of the values.

my %histo;    #histogram of each key's summary data
my %pegs;     #peg count's of each key

#a bit brain boggling, but it works for a sum...
#the (my $value's) are pre-computed at start of the loop
#

foreach my $value (values %hash)
{
    $pegs{$value}++;
    $histo{$value}+=$value;     
}

#
# various print formats...
#
print "histo sort by key:\n";
foreach my $x (sort {$a <=> $b} keys %histo)
{
   print "$x => $histo{$x}\n";
}

print "\nhisto sort by inverse value:\n";
foreach my $x (sort {$histo{$b} <=> $histo{$a}} keys %histo)
{
  print "$x => $histo{$x}\n";
}

print "\nPeg counts of values\n";
foreach my $x (sort {$pegs{$a} <=> $pegs{$b}} keys %pegs)
{
  print "$x => $pegs{$x}\n";
}

=summary of prints:

sort by key of sums:
3 => 6   #keys 3,6
5 => 5   #keys 5
10 => 30 #keys 1,2,5

sort by inverse value of sums: (note swap of $b and $a)
#I did that to make it a bit more interesting...
10 => 30
3 => 6
5 => 5

Peg counts of values: (value and number of times seen)
5 => 1
3 => 2
10 => 3
=cut
[download]

You already have good answers. TIMTOWTDI:

# Frequency of each value.
my %freq;
$freq{$_}++ for values %hash;

# Sort by frequency.
my @bucket;
@bucket[values %freq] = keys %freq;

print "There are $#bucket occurrences of the value $bucket[-1].\n";
[download]