my @sorted_dates = map  { $_->{'date'} }
                   sort { $a->{'year'}  <=> $b->{'year}  or
                          $a->{'month'} <=> $b->{'month} or
                          $a->{'day'}   <=> $b->{'day'}     }
                   map  { /(\d\d)-(\d\d)-(\d\d\d\d)/ ;
                          { 'date'  => $_,
                            'day'   => $1,
                            'month' => $2,
                            'year'  => $3 } } @start_date;

my $minimum_date = $sorted_dates[-1];
[download]

Basically, I'm using a Schwartzian Transform in which I'm retrieving the elements of the date (year, month and day) and I'm sorting the dates by using those elements.

Search for "Schwartzian Transform" here in the Monastery if you don't know what it is. As for the rest, it's just a matter of sorting by year, by month if the years are the same, and by day if the months are the same.

Note that I'm assuming two digit days and two digit months.

cog While I agree that a Schwartzian transfrom is a good idea here, I would like to make two small comments.

1. Rather than doing three comparisons, first on year, then month, then day, I believe (though I haven't benchmarked it) that it would be faster to do a single comaprison of a string in the form yyyymmdd, which can be easily created with a regex.

2. Depending on your data set, it maybe considerable faster to use an Orcish manouver. Especially if the same date may appear multiple time in the list (and I didn't nessicarily see anthing in the post to indicate that that wouldn't happen).

my(%date_hash) = ();

my(@start_date) = qw(01-06-2007 01-08-2006 01-06-2006 01-07-2007 06-01
+-2007);

my @sorted_dates = sort({
                          ($date_has{$a} ||= &trans_date($a))
                          <=>
                          ($date_has{$b} ||= &trans_date($b))
                        } @start_date);

print join("\n", @sorted_dates);

sub trans_date
{
    my $date = shift;
    $date =~ s/(\d{2})-(\d{2})-(\d{4})/$3$2$1/;
    return $date;
}
[download]

---

They say that time changes things, but you actually have to change them yourself.

—Andy Warhol

While I don't disagree with you, I find the Schwartzian transform easier to understand and memorize than an Orcish Manouver, from the view point of a newbie.

Also, the benchmarking would depend largely on the data set (suppose all the years are different, for instance).

Still, I'm inclined to believe that speed won't be relevant, in this case :-) Just a hunch, you know? :-)

The idea is very simple: Convert your dates into something that sort can handle, sort them, and you're done. For example, the strings of the form YYYY/MM/DD sort very well. As you don't show the code you have written, we won't do your homework.

use DateTime;
use DateTime::Format::Strptime;

my @start_date = qw(01-06-2007 01-08-2006 01-06-2006 01-07-2007 06-01-
+2007);

my $Strptime = new DateTime::Format::Strptime( pattern => '%d-%m-%Y' )
+;

my @start_datetimes;
foreach my $datetime ( @start_date ) {
    push  @start_datetimes, $Strptime->parse_datetime( $datetime );
    print $start_datetimes[-1]->ymd('-');
}

print "-"x10;

my @sort_datetimes =
    map  { $_->[0]             }
    sort { $a->[1] <=> $b->[1] }
    map  { [ $_, $_->epoch ]   }
    @start_datetimes;

print $_->ymd('-') foreach @sort_datetimes;

__OUTPUT__
2007-06-01
2006-08-01
2006-06-01
2007-07-01
2007-01-06
----------
2006-06-01
2006-08-01
2007-01-06
2007-06-01
2007-07-01
[download]

my $min;
foreach (@dates) {
    next unless /^(\d+)-(\d+)-(\d+)$/;
    $min ||= ["$3$2$1", $_];
    next unless "$3$2$1" < $min->[0];
    $min = ["$3$2$1", $_];
}
my $mindate = $min->[1];
[download]

use strict;
use warnings;

my @startDates =
   qw(01-06-2007 01-08-2006 01-06-2006 01-07-2007 06-01-2007);

my $leastDate =
   (
      map  {join q{-}, reverse split /-/}
      sort
      map  {join q{-}, reverse split /-/}
      @startDates
   )[0];

print qq{Least date is $leastDate\n};
[download]

When run this produces

Least date is 01-06-2006
[download]

I hope this is of use.

Cheers,

JohnGG

u can use Date::Manip , convert ur dates into epoch and then sort this dates as per your criteria