The code below probably satisfies Q1 - it uses sort alfNum to sort the keys for printing (see below for alfNum).

Given the answer to Q1, Q2 it probably moot.

The answer to Q1 is the answer to Q3.

The key is a user provided compare function used by sort. In this case I've provided one called alfNum:

sub alfNum {
    my ($aAlf, $aNum) = $a =~ /([a-z]+)(\d+)/i;
    my ($bAlf, $bNum) = $b =~ /([a-z]+)(\d+)/i;
    
    return $aAlf cmp $bAlf if $aAlf ne $bAlf;
    return $aNum <=> $bNum;
}
[download]

Note that alfNum returns -1 when $a is less than $b, 0 when they are equal, and 1 when $a is greater.

Prints:

A2                  A10                 A21                 
cc=>5               bl=>0               cd=>5               
dd=>4               ff=>4               de=>4               
ee=>9               gg=>3               ef=>9               

B2                  B3                  B21                 
oo=>5               ec=>3               ee=>3               
pp=>4               oa=>0               og=>0               
zz=>9               wd=>4               wo=>4
[download]

Thank you very much for your answer Im sure it will help me very much. But I would also like to know a simpler thing: Just how to sort an internal hash of an HOH numericaly, the beta-keys or whatever one should call them. I have looked at some examples but, not found what Im looking for, maybee it is so easy nobody cares to make examples of it.

As phrased that is a meaningless question. You can access a hash in sorted order by iterating through a sorted list of keys, but the hash itself is unsorted - that's the nature of the beast.

You can sort an array because each element in the array has a defined position - it's index. But generally that is unimportant for a hash. There are tied hash implementations that allow itteration over the hash keys in sorted order and that may be what you want, but it may not either. At the end of the day the answer depends implicitley on what you are trying to achieve so there is no one answer to "how do I sort a hash?".

---

DWIM is Perl's answer to Gödel

First, please note that hashes are not ordered like arrays are - you cannot sort them and maintain the order within the hash.

Q1: perldsc has some examples of how to sort a %HoH based on the internal keys. Without being more specific, though, I can only guess as to what you intend. I'll assume you want to sort the internal keys within each outer key. In that case, something like:

while( my ( $outkey, $href ) = each %HoH )
{
    foreach my $inkey ( sort { $a <=> $b } keys %{ $href } )
    {
        # do stuff here
[download]

Q2: The tr operator works on single characters only, which means it won't work for double digit numbers. If you've only got single digits (as it sounds), it will work just fine. See perlop for details. If you can't figure out how it works, show us what you've tried and we'd be happy to give you a hand.

Q3: If the keys really are like your example (one upper case letter followed by one or more numbers), you're in luck - sort will do what you want right out of the box (just try it). If your data is a little different, fancier methods are needed (for example, A1 sorts before AA1, and A1 sorts before a1). If that's the case, the Schwartzian Transform could be applied after splitting the alpha and numeric parts (Super Search on this for more examples).

Update: Gah!! For some reason my brain wanted to over simplify the sort for Q3. A custom sort block, such as the ST or the one shown above is definitely needed. Thanks to GrandFather for thinking clearly when I was not.

Here's an example of how the ST could be used. The map-sort-map chain is processed from the bottom up, so start with the keys statement and read "backwards".

    my @inkeys = map
                 {
                    # extract the original key name from the sorted
                    # array refs, and return them in a list to @inkeys
                    $_->[2];
                 }

                 # sort the array refs: first sort alphabetically
                 # (cmp) on the first element, then numerically
                 # (<=>) on the second element
                 sort { $a->[0] cmp $b->[0] || $a->[1] <=> $b->[1] }

                 # 'map' passes a list of array refs to 'sort'
                 map
                 {
                    # split the key name into alpha and numeric parts
                    my ( $alf, $num ) = $_ =~ m/([a-z]+)(\d+)/i;

                    # create an array ref with the two parts of the
                    # key that will be used for sorting, and the
                    # original key name, return the array ref
                    [ $alf, $num, $_ ];
                 } keys %{ $href };
[download]

Finally, don't forget about Super Search and the Tutorials section. They are both a tremendous resource for finding information around here.

Update: If the answers you got in Hash printing problem didn't help you, please be more specific.

If the keys really are like your example (one upper case letter followed by one or more numbers), you're in luck - sort will do what you want right out of the box (just try it).

Err, um, not quite:

use strict;
use warnings;

my @array = qw(a1 a10 a100 a11 b2 b10 b200 b25);

print 'bobf sort: ', join ' ', sort @array;
print "\n  GF sort: ", join ' ', sort alfNum @array;

sub alfNum {
    my ($aAlf, $aNum) = $a =~ /([a-z]+)(\d+)/i;
    my ($bAlf, $bNum) = $b =~ /([a-z]+)(\d+)/i;
   
    return $aAlf cmp $bAlf if $aAlf ne $bAlf;
    return $aNum <=> $bNum;
}
[download]

Prints:

bobf sort: a1 a10 a100 a11 b10 b2 b200 b25
  GF sort: a1 a10 a11 a100 b2 b10 b25 b200
[download]

---

DWIM is Perl's answer to Gödel

Q2: you want a regex substitution, like  s/^(\d)/chr(ord($1)+0x10))/e

Q3:

my @sorted_keys = 
   map { s/_0*//; $_ }
   sort
   map { s/(\d+)/sprintf("_%08d",$1)/e; $_ } keys %hash
[download]

(that's the Schwartzian Transform approach, which might be more efficient, whereas the method that Grandfather suggested is easier to grasp)