@a = qw/foo bar foo baz bar qux foo/; 
$hash{$_}++ foreach @a;
[download]

--

There are 10 kinds of people -- those that understand binary, and those that don't.

my $i = 0;
my $a = 'match_this'

foreach my $b (@array) {
  if ($a eq $b) { $i++ }
}

print "Total occorunces of $a: $i";
[download]

You should try it to see other approaches...

$num_foos = grep {$_ eq 'foo'} @array;
[download]

-- Mike

--
just,my${.02}

I don't understand if you want to count each occurrence of a single letter, that is: from:

you want a report, something like:

a: 1; b: 2; c: 3; and so on, or you want a sub count which counts the recurrences of a single item you pass to it. That is: print count('c',@x) ; # prints 3

Since you already had solutions in the first case, I'll try to answer for the second. The reply is: grep

That is: count should just be something like this:

sub count {
  my ($string,@array) = @_ ;

  # count recurrence of $string in @array
  return scalar grep $_ eq $string, @array ;
}
[download]

For more information on grep you can just do a perldoc -f grep

Ciao!
--bronto

Provided it's not to memory intensive you can stick everything into a hash and iterate through the hash:

foreach $item (@yourList) { $newHash{$item}++; }
print "<TABLE>\n";
foreach $item (keys %newHash) { 
   print "<TR><TD>$item</TD><TD>$newHash{$item}</TD></TR>\n";
}
print "</TABLE>\n";
[download]

This is, of course, a very simple answer and I'm sure there are more efficient ways to do it, but there you are.

EDIT: Whoops, didn't realize this fella posted the same question 3 times (naughty). The original question is already answered quite sufficiently here by mephit in a much more compact way than my solution.

|\/|eraxes

use strict;
my @array = qw(foo bar foobar foobar bar bar bar bar foo foo foo foo b
+ar foobar);
my %hash;
$hash{$_}++ foreach @array;
print "Content-type: text/plain\n\n";
foreach (keys %hash) {
    print "$_ appears $hash{$_} times\n";
}
[download]

foobar appears 3 times
foo appears 5 times
bar appears 6 times
[download]

@list = qw(bing spam bing sponge bob pub time wibble sponge sponge);

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

print map {"$_\t$count{$_}\n"} sort keys %count;
[download]

--
Steve Marvell

Nice fillwords. :)

Makeshifts last the longest.

# to repeat Meraxes
foreach (@array) {
   $seen_hash{$_}++;
}

# then just do a print for each key in the %seen_hash hash
print "Content-type: text/html\n\n";   # viewable in browser
foreach (keys %seen_hash) {
   print $seen_hash{$_};
}
[download]

my (@array, %hash);

push @{$hash{$array[$_]}}, $_ for 0..$#array;

for(keys %hash) {
    print "Element: $_\nOccurences: ", scalar @{$hash{$_}}, "\n";
    print("At indices: ", join(",", @{$hash{$_}}), "\n");
}
[download]