my @indicies = sort { $list[$a] cmp $list[$b] } 0..$#list;
my @rearranged = @list2[@indicies];
[download]

-- Randal L. Schwartz, Perl hacker

my @indicies = sort { $list[$a] cmp $list[$b] } 0..$#list;
my @rearranged;
@rearranged[@indicies] = sort @list2;
[download]

Also see my other solution.

Umm.. this returns zulu xray bravo alpha yankee charlie

that's not ordered right...

Update Yup, all better now
                - Ant

Suppose the question means: given elements of @list2 which begin with the letters of @list, rearrange them so that the beginning letters are sorted in that order. Thus, the length of @list2 in no way correlates with the length of @list, and this was merely a concidence in the sample set.

To that, I'll have to add two arbitrary decisions: if the word doesn't begin with one of the letters, put it first, and within a given initial letter, sort alphabetically.

The code for that would look like this:

my %mapping; @mapping{@list} = 1..@list;

my @rearranged =
  map { $_->[0] }
  sort { $a->[1] <=> $b->[1] or $a->[0] cmp $b->[0] }
  map { [$_, $mapping{substr($_,0,1)} || 0] } @list2;
[download]

And yes, I see other similar solutions in this thread, but I bet those repeated index() calls inside the sort comparator are gonna make it doggy slow for dozens of elements. By caching the reverse map, as well as the sort position, we save mondo time.

-- Randal L. Schwartz, Perl hacker

And here, for completeness, is a (presumably much slower) solution based on the opposite assumptions (extra letters last, and continue the comparison down the string). This is, of course, more or less equivalent to rewriting cmp with your own alphabet. It could undoubtedly be done faster with an iterative solution, but then it could also be done faster in C.

use strict;
use vars '$sortstr';
my @list = qw(a z b y c x); 
my @list2 = qw(zulu zuzu zucu charlie fred xray yankee bravo alpha); 

$sortstr = join('', @list);
my @sorted_list =  sort mycmp @list2; 

sub mycmp {
    my ($A, $B)= @_ ? @_ : ($a,$b);
    my $temp;
    my $Aspot = ($temp = index($sortstr,substr($A,0,1))) < 0 ? 
    length($sortstr) : $temp;
    my $Bspot = ($temp = index($sortstr,substr($B,0,1))) < 0 ? 
    length($sortstr) : $temp;
    
    return 
    $Aspot <=> $Bspot
        ||
        mycmp(substr($A,1),substr($B,1))
        ||
        $A cmp $B
}
[download]

Sorts to:
alpha zuzu zucu zulu bravo yankee charlie xray fred




---

If God had meant us to fly, he would *never* have give us the railroads.
    --Michael Flanders

Here's one suggestion using hash slices:

#!/usr/bin/perl -w
use strict;

my @list = qw(a z b y c x);

my @list2 = qw(zulu charlie xray yankee bravo alpha);

my %hash;

@hash{@list} = @list2;

my @sorted = @hash{sort @list};

print "@sorted\n";
[download]

Update: OK. Misunderstood the question. In that case it's:

@hash{sort @list} = sort @list2;

my @sorted = @hash{@list};
[download]

but merlyn's solution is better :(

"Perl makes the fun jobs fun
and the boring jobs bearable" - me

This doesn't work... he wants to sort the words in order of their first letters based on the @list array... your thing assigns the characters to the items in list 2, then orders that list and reads them, returning...

zulu xray bravo alpha yankee charlie
instead of
alpha zulu bravo yankee charlie xray
                - Ant

what's @hash{@list}?? and wouldn't hasing it up kill duplicates?? wouldn't someone need those duplicates??

more: I ran this and got: zulu xray bravo alpha yankee charlie is this considered sorted??

---

He who asks will be a fool for five minutes, but he who doesn't ask will remain a fool for life.

Chady | http://chady.net/

@hash{@list} is the list of hash values corresponding to the keys in @list.

And, yes, it does break if @list contains duplicates.

--
<http://www.dave.org.uk>

"Perl makes the fun jobs fun
and the boring jobs bearable" - me

use strict;
use warnings;

my $sortorder = 'azbycx';
my @list2 = qw(zulu charlie xray yankee bravo alpha); 

print join ',', @list2,"\n";
print join ',', sort {index($sortorder,substr($a,0,1)) <=> index($sort
+order,substr($b,0,1))} @list2
[download]

--
I'd like to be able to assign to an luser

my $sortstr = join('', @list);
my @sorted_list = sort {
    index($sortstr,substr($a,0,1)) <=> index($sortstr,substr($b,0,1))
        ||
        $a <=> $b
    } @list2;
[download]

Nice idea--I propose the following modification, to dump extra words at the end (and to use string comparison, of course):

my $sortstr = join('', @list);
my @sorted_list = sort {
 rindex($sortstr,substr($b,0,1)) <=> rindex($sortstr,substr($a,0,1))
        ||
        $a cmp $b
    } @list2;
[download]

Of course, you might want words that start with letters not in the list to be at the front, in which case, alphie's solution is preferable (aside from using <=> instead of cmp).

Update: doh! It doesn't do what I thought it did! Fix coming...
Fix here:

my $sortstr = join('', @list);
my @sorted_list = sort {
    my ($tmp1,$tmp2);
 (($tmp1 = index($sortstr,substr($a,0,1))) >= 0 ? $tmp1 : length($sort
+str))
    <=> 
 (($tmp2 = index($sortstr,substr($b,0,1))) >= 0 ? $tmp2 : length($sort
+str))
        ||
        $a cmp $b
    } @list2;
[download]




---

If God had meant us to fly, he would *never* have give us the railroads.
    --Michael Flanders

my(%order);
@order{qw(a z b y c x)} = (0..5);
for(sort { $order{substr($a,0,1)} <=> $order{substr($b,0,1)} } @list2)
+ {...
[download]

my %foo = { 'a' => 'alpha', 'b' => 'bravo', 'c' => 'charlie'};

foreach $x (sort(keys(%foo))) {
print $foo{$x}\n;
}

print $foo{'b'},$foo{'a'},$foo{'c'};
[download]