print join "\n",
  map  { join ',', @{$_->[0]} }
  sort { $a->[1] cmp $b->[1] }
  map  { my $x; for(@$_){$x.=sprintf("%012d",$_)}; [$_,$x] }
  @un_sorted;
[download]

print join "\n",
  map { join ',', @$_ }
  sort {
    for (0..($#{$a}<$#{$b}?$#{$b}:$#{$a})) {
      return $a->[$_] <=> $b->[$_] || $a->[$_] cmp $b->[$_] || next
    }
  } @un_sorted;
[download]

Update: I came up with a better way of handling different-length arrays below.

You need to handle the case when comparing a shorter array with a longer one:

#! perl -slw
use strict;

my @un_sorted = ([3,4,23,4,5],[3,4,56,2,4],[2,3,43,5,3],[2,3,43,6],[3,
+4]);

print join "\n", map{ join ',', @$_ } sort {
    for( 0 .. ( $#{$a} < $#{$b} ? $#{$b} : $#{$a} ) ) {
        return ( $a->[$_] || 0 ) <=> ( $b->[$_] || 0 ) || next
    }
} @un_sorted;
__END__
P:\test>before
Use of uninitialized value in numeric comparison (<=>) at P:\test\junk
+.pl line 10.
2,3,43,5,3
2,3,43,6
3,4
3,4,23,4,5
3,4,56,2,4

P:\test>after
2,3,43,5,3
2,3,43,6
3,4
3,4,23,4,5
3,4,56,2,4
[download]

---

Examine what is said, not who speaks.

"Efficiency is intelligent laziness." -David Dunham
"Think for yourself!" - Abigail
"Memory, processor, disk in that order on the hardware side. Algorithm, algorithm, algorithm on the code side." - tachyon

I'm sorry, but neither you nor Roy Johnson follow the OP insofar as he would like undefined array elements to be treated like infinity rather than zero, that is, he says he wants

3,4,23,4,5
3,4,56,2,4
3,4
[download]

instead of

3,4
3,4,23,4,5
3,4,56,2,4
[download]

Might just have been a typo though, as it's quite unusual.
CombatSquirrel.

---

Entropy is the tendency of everything going to hell.

You're not really handling that case, you're just silencing a warning. Zero and undef still compare as equal. Note the use of cmp to differentiate zero from undef (I may have added that while you were typing your reply).

---

Caution: Contents may have been coded under pressure.

my @sorted = 
  map [ map int, /.{12}/g ], 
  sort map { join '', map { sprintf "%012d", $_ } @$_ } @un_sorted;
[download]

#! perl -slw
use strict;

my @un_sorted = ([3,4,23,4,5],[3,4,56,2,4],[2,3,43,5,3],[2,3,43,6], [3
+,4] );

print join "\n", map{ 
    join ',', @$_ 
} sort {
    for( 0 .. ( $#{$a} < $#{$b} ? $#{$b} : $#{$a} ) ) {
        return
            ( defined( $a->[ $_ ] ) ? $a->[ $_ ] : 1e308 )
            <=>
            ( defined( $b->[ $_ ] ) ? $b->[ $_ ] : 1e308 )
        || next;
    }
    return 0;
} @un_sorted;

__END__
P:\test>junk
2,3,43,5,3
2,3,43,6
3,4,23,4,5
3,4,56,2,4
3,4
[download]

#!perl

use strict;
use warnings;

my @un_sorted = (
   [3, 4, 23, 4, 5],
   [3, 4, 56, 2, 4],
   [2, 3, 43, 5, 3],
   [2, 3, 43, 6],
   [3, 4]
);
my $end = chr(1e6);

print join "\n",
   map { join ',', @$_ }
   map { splice @$_, $#_; $_ }
   map { [(map(ord, split('', $_)))]}
   sort 
   map { join('', map chr, @$_) . $end }
   @un_sorted;
[download]

my @arr4 = sort { $a->[0] cmp $b->[0] } @un_sorted;

print "Mutli-Dimensional Array\n";

for my $i ( 0 .. $#arr4) {
    for my $j (0 .. $#{$arr4[$i]}) { 
       print "$arr4[$i][$j]\t";
    }
    print "\n";
}
[download]

Edited by Chady -- replade <pre> with <code>

Bad on several fronts: You are doing an alphabetical comparison of the first element only; you didn't use <code> tags around your code; and you misspelled "multi". It's generally more Perlescent to iterate over the arrays rather than their indexes.

I don't mean to be discouraging; on the contrary, I hope you will find this assessment helpful. Don't give up. Welcome to the Monestary.

---

Caution: Contents may have been coded under pressure.

my @un_sorted = ([3,4,23,4,5],[3,4,56,2,4],[2,3,43,5,3],[2,3,43,6],[3,
+4],[1,7,99,204],[1],[4,12],[110,99], [1111,19], [99]);

@un_sorted = sort { $a->[0] <=> $b->[0] }  @un_sorted;
[download]