I learned this from ysth other day:

use strict; 
use warnings;

my @num = qw( 00002 00003 00001 99999 99998 );

@num = sort {  
           ( $a < 50000 ) <=> ( $b < 50000 ) || 
           $a <=> $b 
       } @num;

print "sorted: @num \n";

#  sorted: 99998 99999 00001 00002 00003
[download]

if

my @num = qw( 49998 49999 50000 50001 50002 500003)

you get

sorted: 50000 50001 50002 500003 49998 49999

There's got to be a link between the number shown on the page.

Update

How about



sort {
           abs( $a - $b ) > 200 ? $b <=> $a : $a <=> $b
       }
[download]



Y'know I just thought of something - looks like you're reading from a log of some sort

why would you have to sort at all?

Is it even necessary? (Just checking)

Or slightly more compactly (using trinary math instead of the trinary operator):

(abs($a - $b) <=> $max_spread) * ($b <=> $a)
[download]

where $max_spread is the maximum range you expect your numbers to cover before wrapping. 50_000 might be a better choice than 200.

---

Caution: Contents may have been coded under pressure.

Update: man, that is just not right.

MAN THAT AIN'T RIGHT! How simple, it was staring me in the eyes and I couldn't see the tree for the forest. I was trying to make a mountain out of an ant hill. Thanks a lot, that is the definative answer that requires very little in terms of logic.
THANKS everyone else, but trammell is my HERO today.
Thanks again!

Well if anyone was interested, this is what I did to correct my issue:
Orignal Code Snipet


opendir(CacheDir,$Cache) || die "Couldn't open the directory $Cache: $
+!\n";
                @filelist=grep { /[0-9]{5}/ } readdir(CacheDir);
                closedir(CacheDir);                                
                @sortlist=sort {$b <=> $a} @filelist;
                
                for ($i=0;$i<$MsgCount;$i++)
                {
                
                    $filename=$sortlist[$i];
                    if ($filename)
                    {
                      open(ITEM,"$Cache/$filename");
[download]


New Code


opendir(CacheDir,$Cache) || die "Couldn't open the directory $Cache: $
+!\n";
                @filelist=grep { /[0-9]{5}/ } readdir(CacheDir);
                closedir(CacheDir);
                $z=0;
                while($filelist[$z]){
                    if ($filelist[$z] =~ /[0][0][0-1][0-9][0-9]/){
                    $bigfilelist[$z]=int($filelist[$z]+100000);
                    }
                    else{
                        $bigfilelist[$z]=$filelist[$z];
                    }
                    ++$z;
                }
                                
                @sortlist=sort {$b <=> $a} @bigfilelist;
                
                $i=0;                
                while($sortlist[$i]){
                    $filename=int($sortlist[$i]);
                    if($filename > 100000){
                        $filename=int($filename-100000);
                    }
                    else{
                        $filename=int($filename);
                    }
                    $filename=sprintf("%05d", $filename);
                    ++$i;
            
                    if ($filename)
                    {
                      open(ITEM,"$Cache/$filename");
[download]


Again I wanted to thank everyone for their input, I still learned a few things that I will use in the future.
Danny

# ####################
#
# BUG: Assumes less than 5000 messages per minute.
#      There is not enough data to avoid this problem.
#
# BUG: Does not handle messages across different years correctly.
#      There is not enough data to avoid this problem.
#
# ####################

use strict;
use warnings;

use vars qw( %MONTH_TO_INDEX );

BEGIN {
   %MONTH_TO_INDEX = qw(
      Jan  1   Feb  2   Mar  3   Apr  4
      May  5   Jun  6   Jul  7   Aug  8
      Sep  9   Oct 10   Nov 11   Dec 12
   );
}


my $header = <DATA>;
my @data   = <DATA>;

my @sort_data = map  { $_->[5] }
                sort { $a->[0] <=> $b->[0] ||
                       $a->[1] <=> $b->[1] ||
                       $a->[2] <=> $b->[2] ||
                       $a->[3] <=> $b->[3] ||
                       (abs($a->[4] - $b->[4]) < 5000
                          ? ($a->[4] <=> $b->[4])
                          : ($b->[4] <=> $a->[4])
                       ) }
                map  { /^(\d+) \| (\D+)(\d+) \| (\d+):(\d+)/;
                       [
                          $MONTH_TO_INDEX{$2}, # 0: Month
                          0+$3,                # 1: Day
                          0+$4,                # 2: Hour
                          0+$5,                # 3: Minute
                          0+$1,                # 4: id
                          $_,                  # 5: Input
                       ] }
                @data;


print($header, @sort_data);

__DATA__
Transid | Date | Time | PagerID | Message Description 
00004 | Feb10 | 11:18 | sundallas_e | dspmmr3 at ...
00005 | Feb10 | 11:18 | sundallas_e | dspmmr3 at ...
99996 | Feb10 | 11:18 | sundallas_e | dspmmr3 at ...
00000 | Feb11 | 11:17 | hpdallas_e | zcompass at ...
00001 | Feb10 | 11:17 | hpdallas_e | zcompass at ...
99995 | Feb10 | 11:17 | hpdallas_e | zcompass at ...
[download]

Outputs:

Transid | Date | Time | PagerID | Message Description
99995 | Feb10 | 11:17 | hpdallas_e | zcompass at ...
00001 | Feb10 | 11:17 | hpdallas_e | zcompass at ...
99996 | Feb10 | 11:18 | sundallas_e | dspmmr3 at ...
00004 | Feb10 | 11:18 | sundallas_e | dspmmr3 at ...
00005 | Feb10 | 11:18 | sundallas_e | dspmmr3 at ...
00000 | Feb11 | 11:17 | hpdallas_e | zcompass at ...
[download]

Yes, once I reach my max 99999 and the next event's transid is 00001, I need it to sort numerically greater than 99999 as to display:
00001
99999
99998
Thanks.

Is there a reason why you only use 5 digits? The problem I see is that 99999 _is larger_ than 000001. It think it would only work with some kind of "cheating". I wouldn't find it very elegant, because your script has to guess.

If it's in the lower range, 00001 is more likely the one on the bottom. If the numbers are near the top end, you can assume 00001 as first one.

Possibilities I see:
- Using one of the Neuronal Networking Modules on CPAN and train it to decide for you.
- The index numbers do not have holes (eg: nothin' like 99800, 99801, 99803, ..)
_ You make a algorithm which rates 0000n higher if the value processed before was larger and higher as, say 99990.
- Don't let it begin again at 00001

These are (imho) cool, easy, awful and clear :D

Here's my try:

Update: As I see, Razorblade was first :D

use warnings;
use strict;
                                                                      
+          
my @middle = qw( 49998 49999 50000 50001 50002 50003 );
my @limit  = qw( 99997 99998 99999 00001 00002 00003 );
                                                                      
+          
use Data::Dumper;
print "MIDDLE\n";
print Dumper sort ro @middle;
print "LIMIT\n";
print Dumper sort ro @limit;
                                                                      
+          
sub ro { ( abs($a - $b) > 5000 ? $b <=> $a : $a <=> $b ) }
[download]

gives me:

MIDDLE
$VAR1 = 49998;
$VAR2 = 49999;
$VAR3 = 50000;
$VAR4 = 50001;
$VAR5 = 50002;
$VAR6 = 50003;
LIMIT
$VAR1 = 99997;
$VAR2 = 99998;
$VAR3 = 99999;
$VAR4 = '00001';
$VAR5 = '00002';
$VAR6 = '00003';
[download]

hope that helps;phay