You could do this by using a statement similar to your first map.

#!/usr/bin/perl
use strict;
use warnings;

my @x = qw (hi there hello there hello world);
my @y = qw (hi there hello new element there there);

my (%xh,%yh) = ();

# count the number of repeats in each array
$xh{$_}++ for (@x); 
$yh{$_}++ for (@y);

my $common = 0;

# for all keys in the hash check if it exists in the other hash. if it
+ does then choose the min of the two for number of repeats.
for (keys %xh) {
    $common += min($xh{$_}, $yh{$_}) if (exists($yh{$_}));
}

print "Number common = $common\n";

sub min {
    return (($_[0] <= $_[1]) ? $_[0] : $_[1]);
}
[download]

Output

Number common = 4
[download]

In the above list we have hi (1), there (2), hello(1). Note: I have not tested it extensively.

cheers

SK

this was freaking weird.. sorry at least for me- maybe it's my terrible hangover. but.. here goes..

#!/usr/bin/perl

use strict;

my @a1=qw(yo and this too too too a b c d d d d d);

my @a2=qw(yo and too too x f 3 d d moon);


my %a1=();

my %a2=();

for (@a1){
    $a1{$_}++;
    #$found{$_}++;
}

for (@a2){
    $a2{$_}++;
    #$found{$_}++;
}


for (keys %a1){
    $a2{$_} or delete $a1{$_};
}

for (keys %a2){
    $a1{$_} or delete $a2{$_};
}

# now a1 and a2 both contain the same keys, but possibly diff values

my %highest=();

for (keys %a1){ # or a2, same thing
    if ($a1{$_} > $a2{$_} ){
        $highest{$_}=$a1{$_};
    } 
    else {
        $highest{$_}=$a2{$_}; # also if they are the same, non higher 
+then the other
    }
}

for (keys %highest){
    print "$_:$highest{$_}\n";
}
[download]

output is:

yo:1
d:5
and:1
too:3

hope that helps or amuses

package Frobcounting;
sub new {
  my ($class, $a) = @_;
  my $h = {};
  $h->{$_}++ for @$a;
  bless $h, $class;
}
sub new_d {
  my ($class, $a, $b) = @_;
  my $h = {};
  my $h = { a => Frobcounting->new($a),
            b => Frobcounting->new($b) };
  bless $h, $class;
}
sub frobcount { $_[0]->{$_[1]} }
sub frobcount_d {
  my ($fc_d, $e) = @_;
  my $ea = $fc_d->{a}->frobcount($e);
  my $eb = $fc_d->{b}->frobcount($e);
  $ea < $eb ? $ea : $eb
}
sub smaller_d {
  my ($fc_d) = @_;
  my @ka = keys %{$fc_d->{a}};
  my @kb = keys %{$fc_d->{b}};
  @ka < @kb ? @ka : @kb
}

package main;

my $fc = Frobcounting->new_d(\@string1, \@string2);
for (sort $fc->smaller_d) {
  print "$_: ${\$fc->frobcount_d($_)}\n"
}
[download]