my @keys = sort keys %hash; # adapt to your needs here.

for (@keys) {
  print "$_ => $hash{$_}\n";
}
[download]

edit2: This seems to me reasonably efficient:

my @keys = map { tr/a-zA-Z/A-Za-z/; $_ } sort map { tr/a-zA-Z/A-Za-z/;
+ $_ } keys %hash;
[download]

... map { tr/a-zA-Z/A-Za-z/; $_ } ...
[download]

I'm always a bit wary of code that looks like that, especially when it doesn't have the big warning sign to the right that says:

Warning This map alters its incoming arguments as well as generating the desired list. While it is safe in this particular usage, use caution when copying this to another segment of code.

In other words, I'd have written that as:

... map { (my $x = $_) =~ tr/a-zA-Z/A-Za-z/; $x } ...
[download]

which ensures that I get the desired output value without seriously mangling my input value as a side-effect.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

use strict;
use Data::Dumper;

my %h = (
            'John'         => 'P9111',
            'Bob'          => 4711,
            'xavier'       => '20040610',
            'alice'        => '20040610',
        );

my %sk = map ({$_, ($_ =~ m/^[a-z]/) ? 0 : 1} (keys %h));
print Dumper %sk;

my @xk = (sort {$sk{$a} <=> $sk{$b} || $a cmp $b} keys %sk);

print Dumper @xk;

___OUTPUT___
$VAR1 = 'Bob';
$VAR2 = 1;
$VAR3 = 'alice';
$VAR4 = 0;
$VAR5 = 'John';
$VAR6 = 1;
$VAR7 = 'xavier';
$VAR8 = 0;


$VAR1 = 'alice';
$VAR2 = 'xavier';
$VAR3 = 'Bob';
$VAR4 = 'John';
[download]

Instead of using Dumper as you have:

  print Dumper %sk;
  print Dumper @xk;
[download]

You might consider using it like so:

  print Dumper \%sk;
  print Dumper \@xk;
[download]

You should find the output a bit more sensible.

Yeah, thanks, that was actually a typo. I always use the reference with Dumper.

pelagic

with the following keys, in the following order

No, you don't. Hashes don't have any defined order. If you want order, use an array.

{
    my %hash = (
        'Ask'   =>  1,
        'Bob'   =>  1,
        'Cat'   =>  1,
        'amy'   =>  1,
        'ben'   =>  1,
        'can'   =>  1,
    );

    print join "\n", sort case_sorter keys %hash;
}

sub case_sorter {

    my $first_a = substr $a, 0, 1;
    my $first_b = substr $b, 0, 1;

    if ( ($first_a eq uc($first_a)) && ($first_b eq uc($first_b)) ) {
        return $a cmp $b;
    }
    elsif ( $first_a eq uc($first_a) ) {
        return 1;
    }
    elsif ( $first_b eq uc($first_b) ) {
        return -1;
    }
    else {
        return $a cmp $b;
    }
}
[download]

You can not have a sorted hash, but you can sort it's keys before use

foreach ( sort { ord($a) <=> ord($b) } keys %hash ) {
  print "$_ => $hash{$_}\n"
}
[download]

Your comparison is backwards, the OP wants the lowercase first so you need:

foreach ( sort { ord($b) <=> ord($a) } keys %hash ) {
  print "$_ => $hash{$_}\n"
}
[download]

Kudos though, much more elegant than the solution i posted!

That's not quite what was asked by the OP either. output is:

xavier => 1
alice => 1
John => 1
Bob => 1
[download]

"What should it profit a man, if he should win a flame war, yet lose his cool?"

This works after switching the $a and $b.

Thank you all for your kind help.

The original question would lead to odd results when comparing 'Amy' to 'AMy', because 'AMy' would come before 'Amy', since 'M' comes before 'm'. So i was thinking, if lowercase comes before upper case on the first letter, why not for subsequent letters, so heres a neat sorter to deal with it:

    (my $rev_a = $a) =~ tr/A-Za-z/a-zA-Z/;
    (my $rev_b = $b) =~ tr/A-Za-z/a-zA-Z/;

    return $rev_a cmp $rev_b;
[download]

erickn@isfe:/home/erickn> cat t
use warnings;

$hash{John} = '';
$hash{Bob} = '';
$hash{xavier} = '';
$hash{alice} = '';
for my $key (sort {ucfirst($b) cmp lcfirst($a)} keys %hash) {
   print "$key\n";
}


erickn@isfe:/home/erickn> perl t
alice
xavier
Bob
John
[download]

Nope, wont work. Just consider $a = 'amy', $b = 'Ask'. after the case conversion, its comparing then as they were originally, and the capital comes before the lower case.

@keys = ((sort grep(/^[a-z]/, keys %hash)), (sort grep(/^[A-Z]/, keys 
+%hash)));
[download]

That'll make duplicate copies of everything that doesn't begin with a letter. Maybe you want to narrow those regexen down a bit.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

---

update: Oops, confused [^a-z] with ^[a-z]. So yes, everything without a letter will be absent, not duplicated. Doesn't change that there's something wrong with this solution.

Seems to me that it should leave out anything that doesn't begin with a letter. Given the specs, that may or may not be desirable.

---

We're not really tightening our belts, it just feels that way because we're getting fatter.

It seems to me that rather than duplicate all non-first-lettered-words (nice hyphenate don't you think?), it actually discards all these words. I mean, the first list sorts all words which start with a small-case and the second list sorts all the first-upper-cased-words.

I would appreciate explanation.

Update: It seems that my pertinent and correct remark was voted down at least two times. I wonder what that means.

my %hash = qw/John 1 Bob 1 xavier 1 alice 1/;

my @keys = map { tr/a-zA-Z/A-Za-z/; $_ }
           sort
           map { tr/a-zA-Z/A-Za-z/; $_ } keys %hash;

print "@keys\n";
[download]

alice xavier Bob John
[download]

Ditto what I said in •Re^2: Sorting - lower to upper. I guess I'm going to have to watch every node in this thread.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

Taking merlyn's advice into account, I'll change my answer;-)

--from above--

Don't forget about the Schwartzian Transform:

my %hash = qw/John 1 Bob 1 xavier 1 alice 1/;

my @keys = map { (my $x = $_) =~ tr/a-zA-Z/A-Za-z/; $x }
           sort
           map { (my $x = $_) =~ tr/a-zA-Z/A-Za-z/; $x }
           keys %hash;

print "@keys\n";
[download]

Will give you

alice xavier Bob John
[download]

Sorry about that... this thread is growing too fast for me to keep up!