Read in the data to the unsorted list. Ok, this part is easy. :)

my @sorted = @list[
    map { unpack "N", substr($_,-4) }
    sort
    map {
        my $key = $list[$_];
        $key =~ s[(\d+)][ pack "N", $1 ]ge;
        $key . pack "N", $_
    } 0..$#list
];
[download]

Ok this is not as simple to follow.. Lets break it down.

Ok, we are assigning an array slice to the @sorted array. So if the code between the brackets returned "1,5,2,3" then we the sorted array would be assigned $list[1], $list[5], $list[2], $list[3] in that order. The code inside the brackets returns the order which is assigned using an array slice.

map {
    my $key = $list[$_];
    $key =~ s[(\d+)][ pack "N", $1 ]ge;
    $key . pack "N", $_
    } 0..$#list
[download]

What the??? Ok.. lets see.. First lets look at what the map is doing:

Ok, The map is just itterating over the number 0 .. to the subscript of the last element in the array @list. So if there are 5 elements of in the array map will be getting 0 .. 4. So why are we not just doing for $a = ( 0 .. $#list)? That is because we want map to return a modified list to be sorted.

my $key = $list[$_]
$key =~ s[(\d+)][ pack "N", $1 ]ge;
[download]

Now what is going on inside the map? Here we are setting $key to a value from the @list. We then use a greedy regex to globaly replace all numbers with the number packed as a 32 bit Big Endian Number. So the string "Happy4" would be converted to "Happy" . chr(00) . chr(00). chr(00) . chr(04). The modifier to the regex "e" evaluates the right side of the substitution as perl code.

Now we are taking the converted string and adding that elements position in the unsorted array as a packed 32 bit Big Endian Number and returning this value from the map.

This results in a list of the unsorted array with all number converted to 32 bit Big Endian Format and the position tacked on to the last 4 bytes. This list is returned to the builtin sort function which can then sort the resulting array asciibetically. This sorts how we think it should.

Given the strings "apple1", "apple2", "apple3","apple20". A normal sort would return the results in the order:

1. apple1
2. apple2
3. apple20
4. apple3

With the conversion from this routine, the strings are converted to:

1. "apple" . chr(00) . chr(00) . chr(00) . chr(1)
2. "apple" . chr(00) . chr(00) . chr(00) . chr(2)
3. "apple" . chr(00) . chr(00) . chr(00) . chr(3)
4. "apple" . chr(00) . chr(00) . chr(00) . chr(20)

Because of this conversion, the strings sort properly.

Ok now for the last bit of code.

What this does is takes the last 4 chars of each string which is the the position in the unsorted array packed in Big Endian Format and unpacks it and returns it to be used as an array slice.

So given the following

all the following sorts and maps result in a statement that would simplify as

Pretty cool. ++tye!!

So only limitations I can see, would it could only sort a list up to 4,294,967,295 strings.. Not to bad.

Anything you think Im missing.. Or any reason not to use this for sorting these types of strings? Performance issues? Bugs? etc.. You still using it tye?? :)