Calling your array @fruits,

for my $fruit (qw{MANGO APPLES}) {
    print $fruit,
          ' => ',
          scalar( grep { $fruit eq $_ } @fruits),
          $/;
}
[download]

The other and sometimes better way is to count them into a hash,

my %fruit_count;
$fruit_count{$_}++ for @fruits;
for (qw{MANGO APPLES}) {
    print $_, ' => ', $fruit_count{$_}, $/;
}
[download]

if you don't mind can u explain me what is going on here .. i would like to learn it as well so i understand it alot better thanks again

# Declare a hash named fruits.  A hash contains
# { key,value } pairs where the key fields are unique.
my %fruits;

# Get each element in the @fruits array and assign it to
#the { key } portion of the hash.  Also, increment the 
#{ value } part of the hash (the value starts with 0).
#This will count the number of times the { key } appears in
#the array
$fruits{$_}++ for ( @fruits );

#Declare variables for { key, value }
my ( $fruit, $count );

#Get each { key, value } pair and assign them to
#{ fruit, count }
for ( $fruit, $count ) ( each %fruits ) {
    #Print out the number of times the fruit existed.
    print "$fruit => $count\n";
}
[download]

The idea is to loop through the original array. For each element, either look up or add that element as a key into a hash, and increments that key's value by one. Since Perl's hashes use autovivification, when we try to look up a non-existing key in a hash, that key will be added.

$hash{$_}++ for @array;
[download]

is a very common Perl idiom. If we are processing the element 'APPLE' and it is not in the hash, a new key will be added to the hash, and that key's value (currently undef) will be incremented by 1 ... yielding 1. Later, if we encounter 'APPLE' again, when we try to look up 'APPLE' it exists this time and the value returned is 1. Add 1 to that and now we have 2 apples.
Remember, Data::Dumper is your friend! Try this out:

use strict;
use warnings;
use Data::Dumper;

my @fruit = qw(
      MANGO APPLE GRAPES MANGO MANGO MANGO
      MANGO APPLES APPLES BANANA CORN APPLES
);

my %fruit;
$fruit{$_}++ for @fruit;

print Dumper \@fruit;
print Dumper \%fruit;
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

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

my @array = qw(
    mango apples grapes mango mango mango 
    mango apples apples banana corn apples
);

my %count;

$count{$_}++ for @array;

###  Output order not important  ###
print "$_ => $count{$_}\n" for keys %count;

###  Output order is important  ###
my %seen;
for (@array) {
    next if $seen{$_};
    print "$_ => $count{$_}\n";
    $seen{$_} = 1;
}
[download]

#!/usr/bin/perl -w

use strict;
use warnings;
use diagnostics;

my @array = qw(MANGO APPLE GRAPES MANGO MANGO MANGO MANGO APPLES APPLE
+S BANANA CORN APPLES);
my %hash;
foreach (@array)
{
    $hash{$_}++;
}

for my $key(keys %hash)
{
    print "$key => $hash{$key}\n";
}
[download]

use strict;
my @array = <DATA>;
chomp @array;
my %cnt;
$cnt{$_}++ foreach (@array);
print "$_ => $cnt{$_}\n" foreach (keys %cnt);
__DATA__
MANGO
APPLE
GRAPES
MANGO
MANGO
MANGO
MANGO
APPLES
APPLES
BANANA
CORN
APPLES
[download]

use Data::Dumper;

@fruits = qw/ MANGO APPLE GRAPES MANGO MANGO MANGO MANGO
              APPLES APPLES BANANA CORN APPLES /;

map { $count{$_}++ } @fruits;

print Dumper(\%count);
[download]

$VAR1 = {
          'GRAPES' => '1',
          'CORN' => '1',
          'APPLES' => '3',
          'APPLE' => '1',
          'BANANA' => '1',
          'MANGO' => '5'
        };
[download]

Also to illustrate point of 'sort' with hashes, I'd add to this a little. Sorting either by count


@fruits = qw/ MANGO APPLE GRAPES MANGO MANGO MANGO MANGO
              APPLES APPLES BANANA CORN APPLES /;

map { $count{$_}++ } @fruits;

foreach (sort {$count{$a} <=> $count{$b}} keys %count) {
  print "$_ => $count{$_}\n";
}
[download]

Or to sort them by fruits (changing the sort)


foreach (sort {lc($a) cmp lc($b)} keys %count) {
  print "$_ => $count{$_}\n";
}
[download]