Using split, a hash for month sort order look-ups and a ST seems simplest.

$ perl -Mstrict -Mwarnings -E '
my %mthSO = do {
   my $order;
   map { $_, ++ $order } qw{
      Jan Feb Mar Apr
      May Jun Jul Aug
      Sep Oct Nov Dec
      };
   };

say for
   map  { $_->[ 0 ] }
   sort {
          $a->[ 2 ] <=> $b->[ 2 ]
          ||
          $mthSO{ $a->[ 1 ] } <=> $mthSO{ $b->[ 1 ] }
        }
   map  { [ $_, split m{ (?<= [a-z] ) (?= \d ) }x ] }
   qw{ May14 Dec13 Mar14 Oct12 Apr14 };'
Oct12
Dec13
Mar14
Apr14
May14
$
[download]

I hope this is helpful.

Update: Corrected lame-brain wrong comparator for month, thanks AnomalousMonk ++

my %mthSO = do { my $order; map { $_, ++ $order } qw{ ... }; };
...
$mthSO{ $a->[ 1 ] } cmp $mthSO{ $b->[ 1 ] }


Since month names are map-ped to numeric values, shouldn't the month name value comparison be numeric  <=> rather than lexicographic? Adding the dates  Jan14 Dec14 to the test set shows the problem.

Yep, corrected, lamentable senior moment :-(

Cheers,

JohnGG

Plz try to express in words which kind of sorting you really want.

Hi,

I want the output in MMMYY format, the present output is alphabetically sorted but I am trying to print output in MMMYY format sorted way

Expected Output:

key - Dec13 and value - 2
key - Mar14 and value - 2
key - Apr14 and value - 2
key - May14 and value - 2
[download]

So that means you must write your own comparison subroutine, as described in sort. You'll also need to specify ordering on months, since MMM format doesn't naturally sort. Something like:

my %MMM_order = (
    Mar => 3,
    Apr => 4,
    May => 5,
    Dec => 12,
);
sub cmp_MMMYY {
    my ($a_mon, $a_yr) = $a =~ /(.{3})(\d{2})/;
    my ($b_mon, $b_yr) = $b =~ /(.{3})(\d{2})/;

    $a_yr  cmp $b_yr
       or
    $MMM_order{$a_mon}  <=> $MMM_order{$b_mon};
}
[download]

Given the content of your post convert date format from YYYY-MM-DD to YYYYMMDD, I should mention that this sort would be much more natural in ISO 8601, and there are conversion methods discussed in the response to that post.

---

#11929 First ask yourself `How would I do this without a computer?' Then have the computer do it the same way.

You are only repeating not explaining. :(

I'm out! :)

update

If 13 means the year and not the day this could be indeed chronological. (?)

Cheers Rolf

( addicted to the Perl Programming Language)

Yet another way, though I totally agree that a much better solution would be to use an inherently sortable format for the hash keys from the start.

use strict;
use warnings;
use feature 'say';

my %data = ( 
             Apr14 => 2,
             Mar14 => 2,
             May14 => 2,
             Dec13 => 2,
           );  

my %month_to_num = ( 
                    Jan => '01', May => '05', Sep => '09',
                    Feb => '02', Jun => '06', Oct => '10',
                    Mar => '03', Jul => '07', Nov => '11',
                    Apr => '04', Aug => '08', Dec => '12',
                   );  
my %num_to_month = reverse %month_to_num;

say "key - $_ and value - $data{$_}" for 
            map      { s/ (\d{2}) (\d{2}) /$num_to_month{$2}$1/rx } 
            sort map { s/ (\w{3}) (\d{2}) /$2$month_to_num{$1}/rx }
            keys %data;
[download]

If you're going to go to the trouble of two  s/// operations, you might as well go all the way to a GRT/decorate-sort-undecorate solution; then you can at least claim to be getting the maximum possible performance from the Perl sort built-in.

c:\@Work\Perl\monks>perl -wMstrict -le
"my %data = qw(
   Dec02 2  Jan02 3  May05 4  Dec14 8  Dec01 5
   Jan14 7  Apr05 6  Feb14 9  May15 10
   );
 ;;
 use constant Y_WID => 2;
 use constant M_WID => 3;
 my %mon_n = 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 @sorted_dates =
   map unpack(qq{x${\Y_WID} x${\M_WID} a*}, $_),
   sort
   map sprintf('%*s%*s%s', Y_WID, $_->[1], M_WID, $mon_n{$_->[0]}, $_-
+>[2]),
   map [ m{ \A ([[:alpha:]]{${\M_WID}}) (\d{${\Y_WID}}) \z }xms, $_ ],
   keys %data
   ;
 ;;
 print qq{Key - $_  and b value - $data{$_}} for @sorted_dates;
"
Key - Dec01  and b value - 5
Key - Jan02  and b value - 3
Key - Dec02  and b value - 2
Key - Apr05  and b value - 6
Key - May05  and b value - 4
Key - Jan14  and b value - 7
Key - Feb14  and b value - 9
Key - Dec14  and b value - 8
Key - May15  and b value - 10
[download]

Update: See A Fresh Look at Efficient Perl Sorting by Guttman and Rosler (the G and R of GRT). Also: It seems to me now that all the regex sub-string extraction and sprintf-ing would have been much neater, clearer and more maintainable if encapsulated into a separate function. Oh, well...

Took me a while to come full circle to this, but was trying crazy stuff with splice after moving keys to array! ABORT!!!

So, I realized that once months were translated to numbers, concatenating the day and month in reverse would be easily sortable:

 Jul11 = 1107
 Jun11 = 1106
 Aug13 = 1308
 May14 = 1405
 etc...
[download]

Update

sub sortKeys {
    my ( $l_mo, $l_yr ) = $a =~ /(\D+)(\d+)/;
    my ( $r_mo, $r_yr ) = $b =~ /(\D+)(\d+)/;
    my $left  = $l_yr . $months->{$l_mo};
    my $right = $r_yr . $months->{$r_mo};
    return ( $left cmp $right );
}
[download]

sub sortKeys {
    ( my $left  = $a ) =~ s/(\D+)(\d+)/$2 . $months->{$1}/e;
    ( my $right = $b ) =~ s/(\D+)(\d+)/$2 . $months->{$1}/e;
    return ( $left cmp $right );
}
[download]

Modified code below:

#!/usr/bin/perl 

# http://www.perlmonks.org/?node=1087227

use strict;
use warnings;

my $months = {
    "Jan" => "01", "Feb" => "02", "Mar" => "03", "Apr" => "04", "May" 
+=> "05", "Jun" => "06",
    "Jul" => "07", "Aug" => "08", "Sep" => "09", "Oct" => "10", "Nov" 
+=> "11", "Dec" => "12",
};

my $data = {
    "Jul11" => 2, "Dec13" => 2, "Jan14" => 2, "Aug13" => 2,
    "Jun11" => 2, "Apr13" => 2, "Mar12" => 2, "May14" => 2,
};

# using regular sort
print "before:\n";
foreach my $key (sort keys %$data) {
    print "Key - $key  and b value - $data->{$key}\n";
}

# using sortKeys sort
print "after\n";
foreach my $key ( sort { sortKeys( $a, $b ) } keys %$data ) {
    print "Key - $key  and b value - $data->{$key}\n";
}

sub sortKeys {
    ( my $left  = $a ) =~ s/(\D+)(\d+)/$2 . $months->{$1}/e;
    ( my $right = $b ) =~ s/(\D+)(\d+)/$2 . $months->{$1}/e;
    return ( $left cmp $right );
}

__output__
$ ./node_id_1087227_hashkey_sort.pl 
before:
Key - Apr13  and b value - 2
Key - Aug13  and b value - 2
Key - Dec13  and b value - 2
Key - Jan14  and b value - 2
Key - Jul11  and b value - 2
Key - Jun11  and b value - 2
Key - Mar12  and b value - 2
Key - May14  and b value - 2
after
Key - Jun11  and b value - 2
Key - Jul11  and b value - 2
Key - Mar12  and b value - 2
Key - Apr13  and b value - 2
Key - Aug13  and b value - 2
Key - Dec13  and b value - 2
Key - Jan14  and b value - 2
Key - May14  and b value - 2
[download]