Your problem could be because delete does not remove an array element it just sets its value to undef.   To actually remove an array element you need to use splice but you can't do that from inside a loop that is iterating over that array.

Also,  ${$harry{$phash{$k}}}[$bcount] is usually written as  $harry{$phash{$k}}[$bcount].

Try looping like this instead:

for ($acount = $#{$harry{$k}}; $acount >= 0;--$account) {
   my $a = $harry{$k}[$acount];
   for ($bcount = $#{$harry{$phash{$k}}}; $bcount >= 0; --$bcount) {
       my $b = $harry{$phash{$k}}[$bcount];
       if ($a eq $b) ...
           splice(@{$harry{$k}}, $acount, 1);
           splice(@{$harry{$phash{$k}}}, $bcount, 1);
       ...
[download]

See manual page perlsyn:

If any part of LIST is an array, "foreach" will get very confused if you add or remove elements within the loop body, for example with "splice". So don't do that.

UPDATE: jwkrahn is right, delete doesn't shrink the array except when it is the last element, so above manual page excerpt has nothing to do with the problem

Using splice is very inefficient. It scales very poorly. The following is O(K*A1*A2*(A1+A2)):

for my $k ( keys %harry ) {
   my $a1 = $harry{$k};
   my $a2 = $harry{$phash{$k}};

   for (my $i1 = @$a1; $i1-- >= 0; ) {
   for (my $i2 = @$a2; $i2-- >= 0; ) {
      next if $a1->[$i] ne $a2->[$i2];
      splice( @$a1, $i1, 1 );
      splice( @$a2, $i2, 1 );
      ...
   }
}
[download]

If you keep track of the indexes to delete and delete them later, you can greatly improve the scalability. The following is O(K*A1*A2).

for my $k ( keys %harry ) {
   my $a1 = $harry{$k};
   my $a2 = $harry{$phash{$k}};

   my %delete_a1;
   my %delete_a2;

   OUTER:
   for $i1 ( 0 .. $#$a1 ) {
     #next if $delete_a1{$i1};  # Never true.

      for $i2 ( 0 .. $#$a2 ) {
         next if $delete_a2{$i2};
         next if $a1->[$i1] ne $a2->[$i2];

         $delete_a1{$i1} = 1;
         $delete_a2{$i2} = 1;
         next OUTER;
      }
   }

   @$a1 = map $a1->[$_], grep !$delete_a1{$_}, 0..$#$a1;
   @$a2 = map $a2->[$_], grep !$delete_a2{$_}, 0..$#$a2;
}
[download]

You can even do better at the cost of readability. The following is O(K*(A1+A2)).

for my $k ( keys %harry ) {
   my $a1 = $harry{$k};
   my $a2 = $harry{$phash{$k}};

   my %seen;
   for ( @$a1 ) {
      push @{ $h1{$a1} }, $_;
   }

   my %delete_a1;
   my %delete_a2;
   for ( 0..$#$a2 } ) {
      my $seen = $seen{ $a2->[$_] };
      if ( $seen && @$seen ) {
         $delete_a1{$_} = shift(@$seen);
         $delete_a2{$_} = 1;
      }
   }   

   @$a1 = map $a1->[$_], grep !$delete_a1{$_}, 0..$#$a1;
   @$a2 = map $a2->[$_], grep !$delete_a2{$_}, 0..$#$a2;
}
[download]

All of these are fairly complicated because I didn't assume @$a1 and @$a2 each contained only unique elements. If @$a1 contains no duplicates, and if @$a2 contains no duplicates, you could use a simple set difference.

for my $k ( keys %harry ) {
   my $a1 = $harry{$k};
   my $a2 = $harry{$phash{$k}};

   my %seen;
   ++$seen{$_} for @$a1, @$a2;

   @$a1 = grep $seen{$_}>1, @$a1;
   @$a2 = grep $seen{$_}>1, @$a2;
}
[download]

#!/usr/bin/perl

use strict;
use Data::Dumper;

my %hashOfArrays=( a=>[1,2,3], b=>[4,5,6], c=>[7,8,9] );
my %toDelete=( a=>2, b=>6, c=>8 );
for my $array (keys %hashOfArrays) { 
   if ($toDelete{$array}) {   
      $hashOfArrays{$array}=[ 
        grep { $_ != $toDelete{$array} }   
           @{$hashOfArrays{$array}} 
      ];
   }
}
print Dumper(\%hashOfArrays);  
# prints $VAR1 = {
#          'c' => [
#                   7,
#                   9
#                 ],
#          'a' => [
#                   1,
#                   3
#                 ],
#          'b' => [
#                   4,
#                   5
#                 ]
#        };
exit;
[download]

print Dumper(\%harry);
[download]

It is also customary to post (small) segments of your data structures here to help us help you.

my $i = 0;
for my $ele (@array) {
   ...
   $i++;
}
[download]

for my $i (0..$#array) {
   my $ele = $array[$i];
   ...
}
[download]

It's much more readable, and it's not broken by the use of next. (And you don't have to worry about putting the $i=0 in the wrong place like you did.)

The downside is that $ele is no longer an alias. Just use $array[$i] directly if you need to modify the original array. Just can use $array[$i] directly, period.

So, you are stepping through two arrays using foreach $a and foreach $b, and in the inner loop you need the indexes for $a ($acount) and $b ($acount).

You are incrementing $acount and $bcount in the right place -- but you need to set $bcount to zero just before the foreach $b. I suggest that this accounts for your immediate problem.

Other's have pointed out that delete on arrays doesn't actually remove an array element, and if it did who knows whether foreach would cope.

From a style perspective I suggest that calling these indexes $acount obscures their purpose -- which is probably why the problem was hard to see. I would have called them $ia and $ib. Probably best to stick the initialisation of the index hard up against the related foreach.

Also, from a style perspective I wonder whether:

  my $ia = 0 ;
  foreach my $a (@afoo) {

    ... acres of stuff ...

    $ia++ ;
  } ;
[download]

  for my $ia (0..$#afoo) {
    my $a = $afoo[$ia] ;


  } ;
[download]

  my $ia = -1 ;
  foreach my $a (@afoo) {
    $ia++ ;

    ......

  } ;
[download]