I have a hash with a bunch of words as keys, and the number of times
they occured in the file as values.

I want to sort the values and print them out, with their corresponding
keys, in numerical order.

I have no problem doing this with keys, but haven't the slightest idea
how to do it with values.  Yes, I have looked at the perl faq, but
that was no help.

Any help appreciated...
thanks!

I think this information is found in the 'perlfunc' manpage...

Hope it helps...

/Magnus Jonsson

--


 \ (  |
  \_) `-- I only code for fun...

Your answer is in both perlfunc and perlfaq4

(Here's the answer from perlfunc)
"              To sort an array by value, you'll need to use a
               sort() function.  Here's a descending numeric sort
               of a hash by its values:

                   foreach $key (sort { $hash{$b} <=> $hash{$a} } keys %hash) {
                       printf "%4d %s\n", $hash{$key}, $key;
                   }
"

--
Jim Woodgate
Tivoli Systems

 %hash = ( 'dick'  => 5,
           'jane'  => 7,
           'sally' => 2,
           'spot'  => 1,
           'tim'   => 0,
           'puff'  => 3 );

 foreach $key ( sort { $hash{$a} <=> $hash{$b} } keys %hash ) {
    print "$key\t$hash{$key}\n";
 }

--

 perl -e '$n=170;for($d=2;($d*$d)<=$n;$d+=(1+($d%2))){for($t=0;($n%$d)==0;

#!/usr/bin/perl

sub mysort {
    my ($gtl);
    if ( $hash{$a} == $hash{b})
        $gtl = $a cmp $b;
    } else {
        $gtl = $hash{$a} <=> $hash{$b};
    }
    return $gtl;

First, rewrite so that the branches are swapped:

    if ( $hash{$a} != $hash{b} ) {
        $gtl = $hash{$a} <=> $hash{$b};
    } else {
        $gtl = $a cmp $b;
    }

Note that != and <=> evaluate identically in a boolean
context.  So use <=> for the boolean test:

    if ( $hash{$a} <=> $hash{b} ) {
        $gtl = $hash{$a} <=> $hash{$b};
    } else {
        $gtl = $a cmp $b;
    }

Now cache the value of that comparison:

    $gtl = $hash{$a} <=> $hash{$b};
    if ( $gtl ) {
    } else {
        $gtl = $a cmp $b;
    }

Which of course is the same as:

    $gtl = $hash{$a} <=> $hash{$b};
    if ( ! $gtl ) {
        $gtl = $a cmp $b;
    }

A nice shorthand for this situation, which happens
to crop up a lot, is:

    $gtl = $hash{$a} <=> $hash{$b};
    $gtl ||= $a cmp $b;

Of course, if that's all you're doing, you may as well say:

    $gtl = $hash{$a} <=> $hash{$b}
        || $a cmp $b;

So mysort actually looks like this:

    sub mysort {
        my $gtl;
        $gtl = $hash{$a} <=> $hash{$b} || $a cmp $b;
        return $gtl;
    }

Which is obviously nothing more than

    sub mysort {
        $hash{$a} <=> $hash{$b} || $a cmp $b;
    }

Which means you can skip the subroutine altogether:

  for (
    sort { $hash{$a} <=> $hash{$b} || $a cmp $b } keys %hash
  ) {
    ....
  }

I'd like to commend Tony for bringing up the good point
that the hash can be sorted by keys when the values are
equal.

--
John Porter

Often you must create a data structure (like this hash) with a mind for
your special needs.  I often create a hash where the value part is a
reference to a list and sometimes have the key value ALSO be a member of
that value list.  In effect I would have:

%hash = ( fred => ['fred', 1, "a"],
          sue => ['sue', 8, "m" ]
        );

Then I can sort fairly quickly as:

   foreach $entry (sort { $a->[1] cmp $b->[1] } values %hash)
      {
      print "$entry->[0] : $entry->[1]\n";
      }

For many of my uses of Perl I need to have a hash of references to lists
anyway so having the hash's key be another entry in the list is a minor
price to pay.  In effect you have a bunch of records that you want to keep
in a list to sort, etc. but you also need a hash to permit fast lookups --
so have both.