my @ids     = qw/ A1 A2 A3 B5 B6 B7 C789 C790 /;
my @letters = sort keys %{ { map { substr($_,0,1), undef } @ids } };

print "Found the following letters: @letters\n";

__output__

Found the following letters: A B C
[download]

update: fixed bug as noted below by davido

There's a hidden bug in that example. Try running it with a long list of unique alphas and you'll see what I mean. The problem is that in each map iteration you're only creating one item. In your hash assignment, one item is being assigned to the key, and the next to a value. The result is that some letters are being dropped.



Dave

my %hash = map { substr($_, 0, 1), 1 } @original_array;
my @sorted = sort keys %hash;
[download]

Or, less explicitly and without the named temporary hash:

my @sorted = sort keys %{{map{substr($_,0,1 ),1} @original_array}};
[download]

Both methods are really the same thing; they create a hash in order to guarantee uniqueness of keys, and then use the keys to populate a new array after sorting them.

You can answer your own question by trying it, you know ...

One more thing - you don't want grep, you want map.

One more thing - you'll probably want to get the list of unique items. Hint - this is a FAQ.

This will give me an array of ALL the letters, but not the unique letters.

Here's a rather IMHO long winded way to do it:

#!/usr/bin/perl -w
 
my @foo=('A1','A2','A3','B5','B6','B7','C789','C790');
 
my %letters=();
 
my @muut =  map { $letters{substr($_,0,1)}++ } @foo;
 
my @final = sort  keys %letters;
 
printf "%s\n",join(",",@final);
[download]

Technically, you don't need the ++. Just by accessing the hash value creates the key. So, you could do something like:

$letters{substr($_,0,1)} for @foo;
[download]

Though, it is polite to explicitly set it to undef, unless you need the count. :-)

------
We are the carpenters and bricklayers of the Information Age.

Then there are Damian modules.... *sigh* ... that's not about being less-lazy -- that's about being on some really good drugs -- you know, there is no spoon. - flyingmoose

Just by accessing the hash value creates the key.
$letters{substr($_,0,1)} for @foo;

that gives:
Useless use of hash element in void context
besides that, just accessing the hash value does not create it. autovivification only happens if you're accessing an element one level deeper (e.g. in a HoH)

dear all respondees,

thanks for your fast responses, i was in the proces of testing it myself, and had got as far as:

my %seen;
my @sorted = sort($a <=> $b) grep{ $seen{$_}++ } map {substr($_,0,1)} 
+@original_array;
[download]

when i realised y'all were on the board already!!

I just wanted to point out that my code above printed out this list:

A,A,B,B,C

So why did it only print out the extra As and Bs? Out of curiosity.

Thanks again for your help.

Sam

If you need to sort them anyways, an easy way to do it is first sort the array. With the array sorted, identical items will be right next to each other, so to eliminate duplicates you only have to check if an item is the same as the one immediately preceding it, and if so delete it (or not add it to the results). That's essentially how the Unix utility uniq(1) works.

Here's some code I use to do this. It takes a comparison coderef as the first parameter, much like sort, and the array to be sorted and uniqified as the second.

sub uniq(&@)
{
    my($cmpsub, @list)=@_;
    my $last = shift @list
      or return ();
    my @ret =($last);
    foreach (@list)
    {
      push(@ret,$_)
        unless sortcmp($cmpsub,$_,$last)==0;
      $last = $_;
    }
    @ret;
}
[download]

My suspicion is that doing this will be slightly faster than using a hash for very large arrays, but I haven't measured it.

    sub set_of_initials
    {
        my %h;
        local $" = "\n";
        @h{ "@_" =~ /^./sg } = ();
        sort keys %h
    }

    @b = set_of_initials( @a );
[download]