my @unsorted = qw/Psdf lPik Easd aKwe SSdf eqwer scfgh Oegb rqwer T/;
print "pre sorted:  @unsorted\n";

my @sorted = map substr($_, 1),
             sort map { /^[a-z]/ ? "A$_" : "B$_" } @unsorted;

print "post sorted: @sorted\n";

__output__

pre sorted:  Psdf lPik Easd aKwe SSdf eqwer scfgh Oegb rqwer T
post sorted: aKwe eqwer lPik rqwer scfgh Easd Oegb Psdf SSdf T
[download]

That's not a Schwartzian Transform, but a GRT. The code is structurally similar, but works slightly differently. Though some consider the GRT to be a subset of the ST, this is a matter of debate.

----
: () { :|:& };:

Note: All code is untested, unless otherwise stated

hardburn,
Actually it is a variation on the GRT that tye likes to call The One True Sort. The subtle difference is that you do not have to restore the transformation - you can simply throw it away. An example of a classicle GRT would be:

#!/usr/bin/perl
use strict;
use warnings;
my @needs_sorting = qw(Psdgs ldfgs Esdds aSdg Sgsdfs esdf sgfsdfg Osgr
+ T);

@needs_sorting = map { /^[a-z]/ ? "\u$_" : "\l$_" }
               sort
               map { /^[a-z]/ ? "\u$_" : "\l$_" } @needs_sorting;
print "$_\n" for @needs_sorting;
[download]

Cheers - L~R

#!/usr/bin/perl
use strict;
use warnings;
my @needs_sorting = qw(Psdgs ldfgs Esdds aSdg Sgsdfs esdf sgfsdfg Osgr
+ T);

@needs_sorting = map { $_->[0] }
                sort { $a->[1] <=> $b->[1]
                            ||
                    $a->[0] cmp $b->[0] }
                map { [$_ , substr($_ , 0 , 1) =~ /^[a-z]/ ? 0 : 1 ] }
+ @needs_sorting;
print "$_\n" for @needs_sorting;
[download]

print sort {
   if (($a=~/^[a-z]/) == ($b=~/^[a-z]/)) { $a cmp $b }
   else { $b cmp $a }
} @needs_sorting;
[download]

Further update: I liked Broquaint's way of checking initial case.

TMTOWTDI

my @sorted = (( sort grep { $_ eq lcfirst } @unsorted ), 
              ( sort grep { $_ eq ucfirst } @unsorted ));
[download]

dave

Yet another approach to the first part:

  @sorted = sort {
    substr($a, 0, 1) cmp substr($b, 0, 1) || lc($a) cmp lc($b)
  } @needs_sorting;
[download]

Hugo

That's not quite right: your method sorts case-sensitively (uppercase first) on the first letter, and otherwise sorts case-insensitively. Whether the OP wanted the sort to be otherwise case-insensitive is not clear, but he did ask for lowercase initial letters to be first.

Here's a fix:

sort {
   $b=~/^[a-z]/ <=> $a=~/^[a-z]/
   or lc($a) cmp lc($b)
}
[download]

---

The PerlMonk tr/// Advocate

Well to complete this thread, I started digging around in the old nodes, and came across Language::MySort by japhy at Language::MySort.

#!/usr/bin/perl
use Language::MySort;

my @order = ('s'..'z','a'..'r','R'..'Z','A'..'Q');
print q(order-> 's'..'z','a'..'r','R'..'Z','A'..'Q'),"\n";

*my_sort = lang_sort(@order);

my @needs_sorting = qw(Psdgs ldfgs Esdds aSdg Sgsdfs zdef Xrty Msdb es
+df sgfsdfg Osgr T);
print join ',',@needs_sorting,"\n";

my @sorted = my_sort(@needs_sorting);
print join ',',@sorted,"\n";
[download]

OUTPUT:
order-> 'r'..'z','a'..'s','R'..'Z','A'..'Q'
Psdgs,ldfgs,Esdds,aSdg,Sgsdfs,zdef,Xrty,Msdb,esdf,sgfsdfg,Osgr,T,
sgfsdfg,zdef,aSdg,esdf,ldfgs,Sgsdfs,T,Xrty,Esdds,Msdb,Osgr,Psdgs,
[download]

I'm a big fan of Sort::ArbBiLex, myself. It's not quite the perfect lexical sort module, but it'll do for 99.995% of the population.

--
bowling trophy thieves, die!

zentara,
It appears you have a typo in that there is an overlap with 'r'..'z' and 'a'..'s' but it shouldn't cause a problem. Personally, I would steal a page from broquaint's bag of tricks:

#!/usr/bin/perl
use strict;
use warnings;

my @unsorted = ( qw (Psdf lPik Easd aKwe SSdf eqwer scfgh Oegb rqwer T
+) );
my %order = map {$_ => /[r-z]/ ? 'A' : /[a-q]/ ? 'B' : /[R-Z]/ ? 'C' :
+ 'D'} ('a'..'z', 'A'..'Z');

my @sorted = map { substr($_ , 1) }
             sort
             map { $order{ substr($_,0,1) } . $_ } @unsorted;

print "$_\n" for @sorted;
[download]

Cheers - L~R