my @new = do{local %h; ++@h{@a,@b,@c,@d}; keys %h;};
[download]

my @new = keys %{{ map +($_ => undef), @a, @b, @c, @d }};
[download]

It should be noted that the difference to the grep solution is that this won't preserve any kind of order.

Makeshifts last the longest.

Grin:)

 @a=1.10; @b=1..100; @c=1..1000; @d=1..10000;
 use Benchmark 'cmpthese';
 $ari = '@A = keys %{{ map +($_ => undef), @a, @b, @c, @d }};';

 $buk = '@B = do{local %h; ++@h{@a,@b,@c,@d}; keys %h};';

 cmpthese( -1, { ari=>$ari, buk=>$buk });
            (warning: too few iterations for a reliable count)
            (warning: too few iterations for a reliable count)
      Rate  ari  buk
ari 1.69/s   -- -28%
buk 2.36/s  39%   --

cmpthese( -3, { ari=>$ari, buk=>$buk });
      Rate  ari  buk
ari 1.81/s   -- -22%
buk 2.32/s  28%   --

cmpthese( -3, { ari=>$ari, buk=>$buk });
      Rate  ari  buk
ari 1.82/s   -- -24%
buk 2.40/s  32%   --

print 'Same' if "@A" eq "@B"
Same
[download]

---

Examine what is said, not who speaks.
1) When a distinguished but elderly scientist states that something is possible, he is almost certainly right. When he states that something is impossible, he is very probably wrong.
2) The only way of discovering the limits of the possible is to venture a little way past them into the impossible
3) Any sufficiently advanced technology is indistinguishable from magic.
Arthur C. Clarke.

wow. that's amazing. ++ for you.

Hi -

I'm totally baffled about what this section does:

++@h{@a,@b,@c,@d};
[download]

I tried this to peer into the hash:

while ( my ($k, $v) = each %h ) {
  print "$k:$v.\n";
}
[download]

And I just got a bunch of uninitialized value warnings. How does that statement work, and what does it do?

The @h{@a,@b,@c,@d} syntax is a hash slice and it returns a list of all values in %hash that corresponds to keys represented by the array elements. It will auto-vivify elements that do not exist (hence your "uninitiliazed value" warnings). The preincrement operator is apparently taking the final element of the list and incrementing it. In other words, this is an obfuscated way of incrementing a single hash value, but with the side effect of auto-vivifying others. The following code snippet demonstrates:

use strict;
use warnings;
use Data::Dumper;
$Data::Dumper::Indent = 1;

my %hash = (
    foo  => 1,
    bar  => 2,
    baz  => 3,
    quux => 4
);
my @a = qw(foo bar asdf);
my @b = qw(baz);
++@hash{@a,@b};

print Dumper \%hash;
[download]

That auto-vivifies $h{asdf} and increments $h{baz} to 4.

Cheers,
Ovid

New address of my CGI Course.
Silence is Evil (feel free to copy and distribute widely - note copyright text)

Well, you know what

$hash{"key"}
[download]

does - give you access to the value stored in the hash under that key. In the same way, you can say

@hash{"key1", "key2"}
[download]

which gives you access to an entire list of values, indexed by the given keys. This is called a slice (and exists, in analogous form, for arrays too). Now, when you assign to that list, regardless of how many values you provide, all of the keys in the list pop into existence as entries in the hash. If there are not enough values given, any extraneous keys are assigned the undefined value. So

++@h{@a,@b,@c,@d};
[download]

leads to all of the values stored in @a etc being forced to become keys of the hash %h. And because hash keys cannot be duplicated, the list of keys for the resulting hash contains only one instance of each unique element from the arrays used as keys. I personally strongly prefer to write it as

@h{@a,@b,@c,@d} = ();
[download]

For all intents and purposes the effect is the same, it just doesn't look nearly as confusing as the ++ operator on the other one.

Makeshifts last the longest.

I was part way through a long-winded explaination when the latest episode of Enterprise came on. In the meantime the other respondants have explained it much better than I was.

The only addition I would make is that the ++ serves only one purpose, that of inhibiting the "Useless use of hash slice in void context" warning message that results were it not there. I agree with Aristotle that assigning an empty list is a much clearer way of acheiving this, and is the way I will do this in future.

An added bonus is that for anything other than the smallest datasets, it is slightly more efficient.

---

Examine what is said, not who speaks.
1) When a distinguished but elderly scientist states that something is possible, he is almost certainly right. When he states that something is impossible, he is very probably wrong.
2) The only way of discovering the limits of the possible is to venture a little way past them into the impossible
3) Any sufficiently advanced technology is indistinguishable from magic.
Arthur C. Clarke.

@x{@y} = @z; means the same thing as:

foreach my $i (0 .. $#y)
{
    $x{$y[$i]} = $z[$i];
}
[download]

By extension, ++@x{@y}; means (roughly) the same thing as:

for my $i (0 .. $#y)
{
    $i == 0 ? $x{$y[$i]} = 1 : $x{$y[$i]} = undef;
}
[download]

Does that make sense now?

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

Don't go borrowing trouble. For programmers, this means Worry only about what you need to implement.

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

# your arrays
my @a = qw(a c d);
my @b = qw(s d v);
my @c = qw(l d s);
my @d = qw(i c f);

# the hash we'll use to preserve uniqueness
my %unique = ();

# for every character in each of the defined arrays
for my $char (@a, @b, @c, @d) {
    # whenever we run into a character, we set its
    # corresponding value to 1 in the unique hash.  Even if we
    # run into the same character more than once, it'll only have
    # a single entry in our hash, as is the nature of hashes.
    $unique{$char} = 1;
}

# now, the keys in the %unique hash should be the unique
# values from those arrays.  We'll sort the keys for good
# measure
my @unique = sort keys %unique;

# @unique is now the unique elements of those arrays.  Kudos.
[download]

Hashes are your friend (I use them a LOT when looking for duplicates in company data files). Learn to use them wisely and you'll appreciate perl's power and simplicity a lot sooner.

Or, for a quickie:

my %unique = map { $_=>1 } @a, @b, @c, @d;
my @unique = sort keys %unique;
[download]

--
perl: code of the samurai

my @new = do{
    my %seen;
    grep !$seen{$_}++, @a, @b, @c, @d;
};
[download]

Makeshifts last the longest.

Ah, the solution from the FAQ. Unfortunally, the FAQ is wrong. Here's one array where the FAQ solution will give the wrong answer:

    @a = (undef, "");
[download]

Ooops. The FAQ assumes the values map to unique strings. But that isn't true, the undefined value maps to an empty string. And then I haven't shown examples with references, tied variables or objects with overloaded stringification that all can cause the FAQ solution to give the wrong results.

Abigail

The problem is how to define equity once you start slinging around tied or overloaded objects. By equal value, by equal reference, or by entirely different semantics? It's a question with very individual replies depending on the situation, and there can't be a universal solution. As for the undef, which is actually a common case, you are right, I had forgotten about that, even though I've fixed it before.

my @new = do{
    my (%seen, $seen_undef);
    grep defined ? !$seen{$_}++ : !$seen_undef++, @a, @b, @c, @d;
};
[download]

Makeshifts last the longest.

Perhaps a solution would be to use the values instead of the keys, but this means that all the data is copied about again, and so is highly unlikely to be the most efficient approach.

my @new = do{local %h; @h{@a,@b,@c,@d} = (@a,@b,@c,@d); values %h};
[download]

Adapted from BrowserUk's code

--
integral, resident of freenode's #perl

@a = qw (a c d);
@b = qw(s d v);
@c = qw(l d s);
@d = qw(i c f);
@new = (@a,@b,@c,@d);
@new{@new} = ();
@new = keys %new;
[download]

You can tie an array, and it only allows unique values to be added.