@sorted = 
  map { $_->[0] }
  sort { $a->[1] cmp $b->[1] }
  map { (my $tmp = lc $_) =~ s/^the\s+//; [ $_, $tmp ] }
  @indata;
[download]

update: moved parens to the right place on the my.

sub my_sort_key {
 my $file = lc(shift);
 chomp $file;
 my $the_file =~ s/^the\s+//;
 $the_file;
}

my @files = map { $$_[1] } sort { $$a[0] cmp $$b[0] }
 map { [ my_sort_key($_), $_ ] } <INF>;
[download]

1. Don't eat memory:

   my $ignore = '(^The )|(^A )';
   ...
   @sorted = sort { 
       $a =~ s/$ignore//;
       $b =~ s/$ignore//;
       lc( $a ) cmp lc( $b );
     } @indata;
   [download]

2. Or store better keys first:

   %data = map { my $data = $_; s/$ignore//; ($_, $data } @indata;
   
   @sorted = @data{ sort{ lc( $a) cmp lc( $b)} keys %data };
   [download]

Hope this helps,

Jeroen
"We are not alone"(FZ)

2) Filter them out first using grep before sorting.

@temp = map { s/^The // } @indata;
@sorted = sort {lc($a) cmp lc($b) } @temp;
[download]

Update: Actually, it *does not* alter the original values. Note that I assign the map s/// to @temp; @indata remains unchanged. This, from the manpage for map(type it in on this site's search box, for ease).

    %hash = map { getkey($_) => $_ } @array;

is just a funny way to write 


    %hash = ();
    foreach $_ (@array) {
        $hash{getkey($_)} = $_;
    }
[download]

Update (number two): My mistake. . . I did test the code, though I changed it slightly and didn't think to test it again. I'm sorry--I misread the manpage, and misinterpreted what they were doing. This code should do what I meant in the first place:

@temp = map {my $tmp; ($tmp = $_) =~ s/^The //; $tmp} @indata
[download]

You'll find that your s/// has changed your original data. And your 'sorted' array no longer has the word 'The'.

Update:And your map is a 'funny' way to write (thanks for pointing out another bug :-):

for (@array) {
 my $num = s/^The //;
 push @temp, $num;
}
[download]

which DOES modify the original @array. And doesn't put the desired value into @temp ($num is the number of substitutions, which is 0 (undef) or 1).

s/^The\s+// for @temp= @array;         - tye (but my friends call me "Tye")

Yes, it does modify the original values, because the assignment to @temp occurs after the map, and after $_ has been changed in place for each element of @indata.

Furthermore, substitution returns true or false; it does not return the modified string. Therefore, @temp will be a list of null strings and 1s, and @sorted will be a sorted list of null strings and 1s.

Please test your code before posting it, or at least before contradicting a helpful correction from another Perl Monk.

#!/usr/local/bin/perl -w

$, = "\n";

chomp(@indata = <DATA>);

@temp = map { s/^The // } @indata;
@sorted = sort {lc($a) cmp lc($b) } @temp;

print @indata, "---", @temp, "---", @sorted, "---\n";

__DATA__
The Dog
A Bird
The Cat
Lots of Fish
[download]

And the output:

Dog
A Bird
Cat
Lots of Fish

---
1

1


---



1
1
---
[download]