The sort function you have is not sorting by field at all. It is using the whole string. If you look at this line

       map( [$_, (split('|', $_))[-1] ],
[download]

You'll see that it is constructing anonymous arrays where the first element in the array is the whole line ($_) and the second is the looks like it should be last pipe delimited field from that line (split('|', $_))[-1]. It isn't, but I'll get back to that.

However, if the sort block, it is using the first of these two elements $_->[0] which is the whole string.

For reasons I'll admit to not understanding split '|', 'abc|def|ghi' splits not on the pipe char, but every character? It therefore returns the list ('a', 'b', 'c', '|', 'e', 'f', '|', 'g', 'h', 'i')? This may be obvious to everyone else, but it fooled me.

The upshot of that is that when you changed the sort block to be sort( {$a->[1] cmp $b->[1] } what you where actually sorting on was the last character in the string which is the same for every line, hence the apparantly random sort order.

So, to correct that problem, I changed to split /\|/, $_. That means that the anonymous array passed to the sort will contain the string and the last field ([-1]), which isn't helpful if you want to sort by the first two. To address this we need to change that to a slice of the first two fields ([0,1]) and then modify the sort block to use these two fields. However as the second field is numeric, it makes the sort block a little more complicated. We need to compare the two first-fields first and if they are equal, then compare the two second-fields numerically. {$a->[1] cmp $b->[1] || $a->[2] <=> $b->[2]}.

Putting that all together and restructuring the code in the way I find most readable, I get:

$str =
  join("\n",
    map { $_->[0] }
    sort{ $a->[1] cmp $b->[1] || $a->[2] <=> $b->[2] }
    map { [$_, ( split /\|/, $_ )[0,1] ] }
    split/\n/, $str
  );
[download]

As none of the first fields in the sample data are the same, the second field is never compared, but if more or different data is used, the above would handle it.

Having worked through that, I get the sneaking suspicion that this is a very carefully constructed question of the homework variety?

use strict;
use warnings;

use constant FIRST_FIELD => 1;
use constant SECOND_FIELD => 2;
use constant THIRD_FIELD => 3;

my $str = "";
{ local $/; $str = <DATA>; }

$str = join "\n",    map { $_->[0] }
                    sort {$a->[THIRD_FIELD] cmp $b->[THIRD_FIELD] }
                    map { [$_, split('\|', $_)] } split(/\n/, $str);

print $str;

__DATA__
xyz4|1026|CR
xyz3|3461|CR
dert5|3251|PR
rtyaq|251|PR
dbca|583|PR
xxxt|360|CR
[download]

$str = join "\n",    map { $_->[0] }
                   sort {$a->[THIRD_FIELD] cmp $b->[THIRD_FIELD] }
                   map { [$_, split('\|', $_)] } split(/\n/, $str);
[download]

So, how does the schwartzian transform work? First you'll have to realise that the code works from the bottom up, essentially, so this description will have to do so too.

split(/\n/, $str);
[download]

map { [$_, split('\|', $_)] } split(/\n/, $str);
[download]

Now [$_, split('\|', $_)] creates a list with the original string ($_) and then our split up version. So we'd get: ("abc|123|cde", "abc", 123, "cde") from our line above. Map does this across all elements of the following list, so we end up with an list of lists; for example:

( ["abc|123|cde", "abc", 123, "cde"], ["def|222|eee", "def", 222, "eee
+"])
[download]

sort {$a->[THIRD_FIELD] cmp $b->[THIRD_FIELD] }
[download]

sort {$a->[THIRD_FIELD cmp $b->[THIRD_FIELD] ||
      $a->[FIRST_FIELD cmp $b->[FIRST_FIELD]}
[download]

join "\n",    map { $_->[0] }
[download]

I hope that helps you understand how it's supposed to work.

jarich

my $str = `type unsort.txt`;

$str = join("\n", 
        map($_->[0],
            sort( {$a->[1] <=> $b->[1] }#for alpha order change <=> to
+ cmp
              map( [$_, (split('\|', $_))[1] ],#change this number to 
+control which field to use, 0 for 1st field 
                   split(/\n/, $str)
                 )
             )
           )
           );

print $str;
[download]

1. the split breaks the content of the file, into lines. Now we have a list contains all the lines;
2. the inner map creates a list of array ref, which refs an array of two elements, the first one holds the entire line, when the second one contains the sorting key. You can choose which field to be used as the key;
3. the sort sorts by the 2nd element, which is the key we choosen;
4. the outter map then creates a list contains only the whole lines;
5. finally, the join put the line breaks back, and form a string.

#!/usr/bin/perl

while (<>) {
    $str .= $_;
}

@lines = split ("\n", $str);

@sorted = sort fooSort @lines;

foreach $line (@sorted)
{
    print ("$line\n");
}

sub fooSort {
    my @a = split '\|', $a;
    my @b = split '\|', $b;
    $a[0] cmp $b[0] || $b[1] <=> $a[1]
}
[download]