my @sorted_indices = sort { $array[$a] <=> $array[$b] } (0..$#array);

# If you need to get back the sorted array, use this
# without the extra sort step.
my @sorted_array = map { $array[$_] } @sorted_indices;
[download]

Update fixed slight problem in first line of code

-----------------------------------------------------
Dr. Michael K. Neylon - mneylon-pm@masemware.com || "You've left the lens cap of your mind on again, Pinky" - The Brain
"I can see my house from here!"
It's not what you know, but knowing how to find it if you don't know that's important

The last step can be simplified:     my @sorted_array= @array[@sorted_indices];

        - tye (but my friends call me "Tye")

UPDATE: Erk. No we didnt. /me removes lenscap from eyes. Read Masems reply to my post below. OTOH introducing the ST is never a bad thing, just perhaps not the most appropriate thing ;-)

My interpretation is that you want to sort the list, but be able to determine the elements original positions afterwards. The way to do this is a twist on the Schwartzian Transform.

Basically the idea being that you transform the list into an intermediate form, one that holds the meta info you need, sort as normal and then either use the meta version and or unpack it into the sorted form.

use strict;
use warnings;

my @array=qw(Q W E R T Y U I O P);
my @sorted_meta=sort { $a->[0] cmp $b->[0] } map { [ $array[$_] , $_ ]
+ } 0..$#array;
my @sorted=map { $_->[0] } @sorted_meta;

local $,=" ";
local $\="\n";
print "Orig: ",@array;
print "Meta: ",map { ("[",@{$_},"]") } @sorted_meta;
print "Sort: ",@sorted;
__END__
Outputs:
Orig:  Q W E R T Y U I O P
Meta:  [ E 2 ] [ I 7 ] [ O 8 ] [ P 9 ] [ Q 0 ] [ R 3 ] [ T 4 ] [ U 6 ]
+ [ W 1 ] [ Y 5 ]
Sort:  E I O P Q R T U W Y
[download]

Anyway, hope one of us has managed to answer the question you were asking.. :-)

Yves / DeMerphq
--
When to use Prototypes?

You're going to get the ability to get the same result in either fashion. However, for my reply to a similar question on array sorting, merlyn pointed out that the ST is overly heavy for the sorting, and the method that I suggested above was better for getting the sorted indices. Now, with mine, you can rebuild the sorted array via the map I provided, but it's just as easy to do this as well:

@sorted_indices = sort {...} (0..$#array); # as above
@sorted_array = map { $array[$_] } @sorted_indices;  #as above
my @to_position;
$to_position[ sorted_indices[ $_ ] ] = $_ foreach (0..$#array);  # thi
+s is new
[download]

IMO, I believe this is more lightweight and a bit easier to follow for the given code than using the heavier ST for the same. Not that the ST can't be useful in a similar situation if the comparison values are heavy in terms of calculation times, but here they defintely aren't.

-----------------------------------------------------
Dr. Michael K. Neylon - mneylon-pm@masemware.com || "You've left the lens cap of your mind on again, Pinky" - The Brain
"I can see my house from here!"
It's not what you know, but knowing how to find it if you don't know that's important

my $count = 0;
my %hash = map {$_, $count++} @array;
my @sort = sort { int($a) <=> int($b) } @array;

my $flag = 0;
for (@sort) {
    print ', ' if $flag++;
    print qq|"$_" came from | . '$array[' . $hash{$_} . ']';
}
[download]

--Dave

Great code! I did notice however that it doesn't allow for
duplicate numbers :^(
So I revised it ever so slightly to be:

my $count = 0;
my %hash = map {$count++, $_} @array;
my @sort = sort { int($a) <=> int($b) } @array;

my $flag = 0;
for (keys %hash) {
    print ', ' if $flag++;
    print qq|"$hash{$_}" came from | . '$array[' . $_ . ']';
}
[download]

@array = (3,2,1);
$array[4] = 0;
my $i = 0;
foreach (
          sort { $a->[1] cmp $b->[1] } # or better <=> for numbers ins
+tead of cmp
          map { [$i++, $_ ] } @array
         ){
  my $number = $_->[1];
  my $originalIndex = $_->[0];

  # do something with $number and $originalIndex...
} # foreach
[download]

Best regards,
perl -e "print a|r,p|d=>b|p=>chr 3**2 .7=>t and t"

#initialize array
@array = (12,7,4);

$i=0;
foreach (@array) {
   #Throw in a hash to look up in a second
   $hash{$_} = $i;
   $i++;
}

#sort it, loop through, and look up from hash from above
foreach (@num_sorted_array = sort { $a <=> $b } @array) {
  print "$_ came from \$array\[$hash{$_}\]\n";
}
[download]

This doesn't allow for duplicate values in the array, the
hash value will get changed to the highest number matched.
See my earlier post for a version that allows for duplicates.
I am also not sure if the fact duplicates aren't handled are
a concern to the original poster, I just know I have been
bitten by this before. :^)
Sorry I didn't take the time to see if your code be modified
to allow for dups.

#initialize array
@array = (12,7,4);

$i=0;
foreach (@array) {
   #Throw in a hash to look up in a second
   $hash{$_} = $i;
   $i++;
}

#sort it, loop through, and look up from hash from above
foreach (@num_sorted_array = sort { $a <=> $b } @array) {
  print "$_ came from \$array\[$hash{$_}\]\n";
}
[download]