sub numeric {$a <=> $b}

The <=> operator will take care of everything! Of course you will need to change the above sub to fit exactly your needs, but that should be a piece of cake. :-) If not dare to ask again :-)

Bye,
C-Keen

You need to use a numeric sort (the default is alphabetic). Provided the numbers are at the start of the line you can just do this:

my @data = <DATA>;
my @alpha_sort   = sort { $a cmp $b } @data;
my @numeric_sort = sort { $a <=> $b } @data;

print "Alpha sort\n@alpha_sort\n";
print "Numeric sort\n@numeric_sort\n";

__DATA__
123.45Hello
32.2World
1.5Just
288.2Another
288.3Perl
288.4Hacker
[download]

If you have more complex requirements then a Schwartzian transform will be in order.

cheers

tachyon

s&&rsenoyhcatreve&&&s&n.+t&"$'$`$\"$\&"&ee&&y&srve&&d&&print

1. Zero-pad your numbers, so generate them with

   my $padded=sprintf("%08.3f",39.452);
   [download]

   You can do this while reading your data:

   while (<>){
     split /:/;
     $_[0]=sprintf("%08.3f", $_[0]);
     push @data, join ":", @_;
   }
   [download]

2. Or you can sort numerically. This requires you to extract the numbers and sort on them with <=> (see perlop), like

       sort{ $a <=> $b} @numbers;
   [download]

   . You can write a sub for the extraction:

   sort{extract( $a ) <=> extract( $b )} @lines;
   
   sub extract{
     $a = shift;
     split /:/, $a;
     $_[0];
   }
   [download]

3. It's better to extract your numbers, and use them as keys in a hash, and work with a list of sorted keys:

   my %hash;
   while(<>){
     my ($key, $data) = split( /:/, $_, 2 );
     $hash{ $key } = $data;
   }
   print "Sorted!:\n\n", join "|", sort {$a <=> $b} keys %hash;
   [download]

4. .... many more paths to come up with

HTH,

Jeroen
"We are not alone"(FZ)
(code untested, you'll get the idea)

Update
Albannach is right of course. Still, if you have quite some data, a hash-lookup is more efficient. And more scalable, as you can tie your hash onto a database, e.g. To prevent that double-count problem, add a check in for the key, if a double, add a counter or something.

$key .= ':001' if defined $hash{$key};
$key++ while defined $hash{$key};
[download]

Note that in your option 3 the unique keys of the hash will be likely to clobber some data as the anonymonk specified that the first value is price in his problem. Hashes are great for many reasons but this example is easily and simply addressed by a simple numerical sort so unless there is reason to need to search the data by price, and a certainty of unique pricing, I'll go with one of your first two options.

--
I'd like to be able to assign to an luser

@a = qw(39 45 120 139);
@b = sort(@a);

@c = sort { $a <=> $b } @a;

print "B : ",join(',',@b),"\n"; # B : 120,139,39,45
print "C : ",join(',',@c),"\n"; # C : 39,45,120,139
[download]

force comparing when you sort :

foreach $line (sort { (split /:/, $a)[0] <=> (split /:/, $b)[0] } @lis
+t){
...
[download]

print('1.01:dfsfda'+'1.34:kjlkljkj',"\n");
# prints 2.35\n
[download]

@sorted = sort { $a <=> $b } @data;
[download]

                - Ant
                - Some of my best work - Fish Dinner

True. But I don't think anyone has mentioned that this will generate warnings. But you can turn them off around that part of the code:

my @sorted= do {
    local( $^W )= 0;
    sort { $a <=> $b } @data;
};
[download]

        - tye (but my friends call me "Tye")

Or if you're using a 5.6 or newer perl you can turn off just warnings about the numericness (see perllexwarn for more information).

my @sorted = do {
                   no warnings 'numeric';
                   sort { $a <=> $b } @data ;
                };
[download]

@res = sort { int($a) <=> int($b) } <DATA>;
print foreach(@res);

__END__
34:dsfalk:as4
2:asd:3425
67:dfa:srkwej9
98:erwvrklj:sek

output -
2:asd:3425
34:dsfalk:as4
67:dfa:srkwej9
98:erwvrklj:sek
[download]

broquaint

@lines = (
           q{23.40:hello:this:is:a:line},
           q{123.38:this:is:another:line},
           q{7.32895:yet:another:line},
         );

@sorted = map { $_->[1] }
              sort { $a->[0] <=> $b->[0] }
                   map { [ (split(/:/,$_))[0], $_ ] }@lines;
[download]

Of course, if you're going to split things anyhow, it might make just as much sense to go ahead and split the whole line and just use that.

@split = sort { $a->[0] <=> $b->[0] } map { [ split /:/ ] } @lines;
[download]