So just sort it ;)

my @lines = ('124.43.adsf.ca', '235.23.aer.ca', '100.34.asdm.ca'); # c
+reate the unsorted array
my @sorted = sort @lines; # create the sorted array
for (@sorted) { print "$_\n"; } # display
[download]

This displays:
100.34.asdm.ca
124.43.adsf.ca
235.23.aer.ca

Emm... realized where my error lies. Thanks. Initially I tried what you said did not work. But I know why. i was reading each files from directory. Due to logic error, I did not obtain a sorted list. I was able to fix. I thought it was due to the "." in the numbers. Thanks.

Any time kanabrian, I'm glad to help!

use strict;
use Data::Dumper;

my @data = qw( 124.43.adsf.ca 235.23.aer.ca 100.34.asdm.ca );

my @sorted = map { $_->[ 0 ] }
             sort { $a->[1] cmp $b->[1] }
             map { [$_, /(\d+\.\d)/] }
             @data;
[download]

Greets,

-- JaWi

"A chicken is an egg's way of producing more eggs."

I'm curious why you want that ordering, but never mind. Here is a Schwartian transform method with priority ordering.

my @sorted_lines =
    map {join '.', @$_}
    sort { $a->[0] <=> $b->[0]
           || $a->[1] <=> $b->[1]
           || $a->[2] cmp $b->[2]
           || $a->[3] cmp $b->[3]}
    map { [split '.'] } 
    @lines;
[download]

Reading right-to-left, each element of @lines is transformed to a reference to an array of the dot seperated values. Then the transformed array is sorted with left-to-right priority in the elements. Only if a comparison of the zero-th elements comes up equal, is the one-th elements compared. That is from the short-circuit behavior of the || operator. Finally the sorted array is turned back into its original form with the join map.

Those transformations are done to avoid many expensive calls to split and the associated creation of temporary variables.

After Compline,
Zaxo

@sorted = map { $_->[0] }
          sort { $a->[1] <=> $b->[1] ||
                 $a->[2] <=> $b->[2] ||
                 $a->[3] cmp $b->[3] ||
                 $a->[4] cmp $b->[4] }
          map { [ $_, split(/\./, $_) ] } @lines;
[download]

@sortedlines = map{(split)[1]}
               sort
               map{sprintf"%09d%09d%s%s %s",(split/\./)[0..3],$_}
               @lines;
[download]

That will break if any of the elements have spaces in them. Probably not very likely, but a safer way to write a GRT is:

my @sorted = map{(split(/\0/))[1]}
             sort
             map{sprintf"%09d%09d%s%s\0%s",(split/\./)[0..3],$_}
             @lines;
[download]

-Blake

#!/usr/local/bin/perl -w
use strict;
my @stuff = qw (124.43.adsf.ca 235.23.aer.ca 100.34.asdm.ca);
my %hash = map { $_, m{(\d+(?:\.\d+)*)} } @stuff;

@stuff = sort {$hash{$a} <=> $hash{$b}} keys %hash;

print join "\n", @stuff;
[download]