This is perl, version 5.005_03 built for aix
AIX pbsxdr00041 2 5 000258CA4C00
>perl sort.pudge h2z.prod.400987aa > h2z.prod1a
Use of uninitialized value at sort.pudge line 266.
####
20040623CC255533 3130 268713110 3 20040623
8.96 1.000
####
>perl -w sort.pudge -d h2z.prod.400987aa > h2z.prod1a
Out of memory!
####
"perl_sort.pl" 7 lines, 301 characters
#/usr/bin/perl
open(MYINPUTFILE, "; # read file into list
@lines = sort(@lines); # sort the list
my($line);foreach $line (@lines) # loop thru list
{ print "$line"; # print in sort order
} close(MYINPUTFILE);
####
/opt/vrs/files/PROD_8 PBN2I]
>perl -w perl_sort.pl
Out of memory!
####
#!/usr/bin/perl
open (ORIGFILE,
"H2Z_ZDL0.000");
open (FINALFILE, ">sorted.txt");
print FINALFILE
sort();
close (FINALFILE);
close (ORIGFILE);
####
$ perldoc -t -f sort
sort SUBNAME LIST
sort BLOCK LIST
sort LIST
In list context, this sorts the LIST and returns the sorted list
value. In scalar context, the behaviour of "sort()" is
undefined.
If SUBNAME or BLOCK is omitted, "sort"s in standard string
comparison order. If SUBNAME is specified, it gives the name of
a subroutine that returns an integer less than, equal to, or
greater than 0, depending on how the elements of the list are to
be ordered. (The "<=>" and "cmp" operators are extremely useful
in such routines.) SUBNAME may be a scalar variable name
(unsubscripted), in which case the value provides the name of
(or a reference to) the actual subroutine to use. In place of a
SUBNAME, you can provide a BLOCK as an anonymous, in-line sort
subroutine.
If the subroutine's prototype is "($$)", the elements to be
compared are passed by reference in @_, as for a normal
subroutine. This is slower than unprototyped subroutines, where
the elements to be compared are passed into the subroutine as
the package global variables $a and $b (see example below). Note
that in the latter case, it is usually counter-productive to
declare $a and $b as lexicals.
In either case, the subroutine may not be recursive. The values
to be compared are always passed by reference, so don't modify
them.
You also cannot exit out of the sort block or subroutine using
any of the loop control operators described in perlsyn or with
"goto".
When "use locale" is in effect, "sort LIST" sorts LIST according
to the current collation locale. See perllocale.
Perl 5.6 and earlier used a quicksort algorithm to implement
sort. That algorithm was not stable, and *could* go quadratic.
(A *stable* sort preserves the input order of elements that
compare equal. Although quicksort's run time is O(NlogN) when
averaged over all arrays of length N, the time can be O(N**2),
*quadratic* behavior, for some inputs.) In 5.7, the quicksort
implementation was replaced with a stable mergesort algorithm
whose worst case behavior is O(NlogN). But benchmarks indicated
that for some inputs, on some platforms, the original quicksort
was faster. 5.8 has a sort pragma for limited control of the
sort. Its rather blunt control of the underlying algorithm may
not persist into future perls, but the ability to characterize
the input or output in implementation independent ways quite
probably will. See sort.
Examples:
# sort lexically
@articles = sort @files;
# same thing, but with explicit sort routine
@articles = sort {$a cmp $b} @files;
# now case-insensitively
@articles = sort {uc($a) cmp uc($b)} @files;
# same thing in reversed order
@articles = sort {$b cmp $a} @files;
# sort numerically ascending
@articles = sort {$a <=> $b} @files;
# sort numerically descending
@articles = sort {$b <=> $a} @files;
# this sorts the %age hash by value instead of key
# using an in-line function
@eldest = sort { $age{$b} <=> $age{$a} } keys %age;
# sort using explicit subroutine name
sub byage {
$age{$a} <=> $age{$b}; # presuming numeric
}
@sortedclass = sort byage @class;
sub backwards { $b cmp $a }
@harry = qw(dog cat x Cain Abel);
@george = qw(gone chased yz Punished Axed);
print sort @harry;
# prints AbelCaincatdogx
print sort backwards @harry;
# prints xdogcatCainAbel
print sort @george, 'to', @harry;
# prints AbelAxedCainPunishedcatchaseddoggonetoxyz
# inefficiently sort by descending numeric compare using
# the first integer after the first = sign, or the
# whole record case-insensitively otherwise
@new = sort {
($b =~ /=(\d+)/)[0] <=> ($a =~ /=(\d+)/)[0]
||
uc($a) cmp uc($b)
} @old;
# same thing, but much more efficiently;
# we'll build auxiliary indices instead
# for speed
@nums = @caps = ();
for (@old) {
push @nums, /=(\d+)/;
push @caps, uc($_);
}
@new = @old[ sort {
$nums[$b] <=> $nums[$a]
||
$caps[$a] cmp $caps[$b]
} 0..$#old
];
# same thing, but without any temps
@new = map { $_->[0] }
sort { $b->[1] <=> $a->[1]
||
$a->[2] cmp $b->[2]
} map { [$_, /=(\d+)/, uc($_)] } @old;
# using a prototype allows you to use any comparison subroutine
# as a sort subroutine (including other package's subroutines)
package other;
sub backwards ($$) { $_[1] cmp $_[0]; } # $a and $b are not \
set here
package main;
@new = sort other::backwards @old;
# guarantee stability, regardless of algorithm
use sort 'stable';
@new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
# force use of mergesort (not portable outside Perl 5.8)
use sort '_mergesort'; # note discouraging _
@new = sort { substr($a, 3, 5) cmp substr($b, 3, 5) } @old;
If you're using strict, you *must not* declare $a and $b as
lexicals. They are package globals. That means if you're in the
"main" package and type
@articles = sort {$b <=> $a} @files;
then $a and $b are $main::a and $main::b (or $::a and $::b), but
if you're in the "FooPack" package, it's the same as typing
@articles = sort {$FooPack::b <=> $FooPack::a} @files;
The comparison function is required to behave. If it returns
inconsistent results (sometimes saying $x[1] is less than $x[2]
and sometimes saying the opposite, for example) the results are
not well-defined.
Because "<=>" returns "undef" when either operand is "NaN"
(not-a-number), and because "sort" will trigger a fatal error
unless the result of a comparison is defined, when sorting with
a comparison function like "$a <=> $b", be careful about lists
that might contain a "NaN". The following example takes
advantage of the fact that "NaN != NaN" to eliminate any "NaN"s
from the input.
@result = sort { $a <=> $b } grep { $_ == $_ } @input;