Precedence is biting you. You are concatenating @{$_}[0..2] . " " etc, which is not what you intended. Aside from other problems, this evaluates the array slice in scalar context, for the last element, $_->[2], dropping the other two elements.

Solution: Parentheses. For example, to make the first join a function call instead of a list operator:

#!perl
use strict;
use warnings;

my ($mdate,$mts) = @ARGV;
my $recent =    (map { join("-", @{$_}[0..2]) . " " . join ":", @{$_}[
+3..5] }
                 sort { $a->[0] <=> $b->[0] || $a->[1] <=> $b->[1] || 
+$a->[2] <=> $b->[2] }
                 map { [ split "[-: ]" ] } ($mdate,$mts))[0];
print $recent;
[download]

You probably want some parentheses. The concatenation operator (period) binds more tightly than the list operator (comma), so your code as it stands is doing the second join, then the concatenation (which evaluates the slice in scalar context), then the first join (thus, no hyphens, because the concatenation produces only one value for join to join). Put parentheses around the first join to make it evaluate before the concatenation, and Bjorn Stronginthearm is your uncle.

my $recent = ( sort @ARGV )[ 0 ];

[download]

Yes, in this case is true. Anyway is the significative part of a biggest piece of code that sorts and compares different date and time formats in a trying to be fast way, and so the need to split and rejoin.

How could splitting and rejoining be faster than a plain string sort, if they are not needed? (If they were, it would be a different story, of course.)