Can anyone explain this code and how its working.

grep applies the block { !$seen{$_}++ } on each element of @a and depending on the result of that application, skips the element or returns it. Inside the block the current element from @a is in $_. The block returns the negation of the value stored under the key $_ in the hash %seen.

Inside the block, in the hash %seen, the value keyed on $_ is at first undefined; it is incremented - but with a post-increment, so on the first occurrence of the hash key stored in $_, the negation (!$seen{$_}) of that undefined (false) value is 1 (or true). So,on the first occurrence the block returns a true value, and the currently evaluated element from @a passes the grep. On the next occurrence of the same hash key the value is already set to a positive integer, which when negated results in a false value - the element doesn't pass the grep.

Yes, I know, the above text needs to be read twice...

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

Yes, I know, the above text needs to be read twice...

yes, it does --- but it is well worth the read! nicely done shmem++

use Data::Dump 'pp';

my @a = qw/2 1 3 4 5 4 3 3 4 5/;
my %seen;
my @result;

for ( @a ) {               #for each element in @a
    if ( not $seen{$_} ) { #if the element hasn't already been seen
        push @result, $_;  #add it to the result set
    }
    $seen{$_}++;           #note that the element's been seen
}

print join(",", @result), "\n";

pp \%seen;                 #{ 1 => 1, 2 => 1, 3 => 3, 4 => 3, 5 => 2 }
[download]

Each value in %seen is a count of how many times the key's been seen

Update: Removed a misleading comment & corrected a typo
Update^2: replaced say with print for perl<5.10 compatability (as suggested by ww)

This approach is merges the construction of the %seen hash with the extraction of unique elements.

1. reading elements from @array

2. If the current element ($_) and it is not in the hash (%seen), it will push into @result. Then it stored into hash(%seen). As we know hash will not allow duplicate value

Thanks
Gopal

%seen will also have the number of occurrences of every element of @a.

How? If the array (@a) has duplicate values, hash will eliminate that.

This code reminded me of a perlfaq and I was right; see How can I remove duplicate elements from a list or array? (3rd question in section "Data: Arrays")

It contains an explanation which results in the code you mentioned.

my @result = grep { !$seen{$_}++ } @a;
[download]

grep then foreachs through the list @a and for every element it sets $_ = that element.

1) if there is no entry in the %seen hash then it puts a zero in there. So the $seen{$_} evaluates to (0)false. Add the ! negation operator and you can see that the expression passed to grep only evaluates to true for values on their first encounter. Furthermore, the ++ is post-increment so it happens after expression returns it's value.

grep will just will just run through it's list checking the expression against each element. The elements that evaluate to true are returned as @result.