You want the splice operator.

Incidentally, to get away with removing elements from an array in a for loop, you need to take them in reverse order:

for (reverse 0 .. $#a) {
    splice @a, $_, 1 if condition($a[$_]);
}
[download]

You appear to be taking the set differences of two arrays. That has a well-known technique in perl:

my (%a, %b);
@a{@a} = ();
@b{@b} = ();
delete @a{@b};
delete @b{@a};
@a = keys %a;
@b = keys %b;
# or if order matters,
# @a = grep {exists $a{$_}} @a;
# @b = grep {exists $b{$_}} @b;
[download]

While splice is the way to remove elements from an array, nb 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.

In this situation I usually (as others have suggested) use a C-style for loop.

Hence reverse. If you remove or insert elements from the end, the positions of unvisited elements are not affected.

After Compline,
Zaxo

If deletion is so often, you probably should use hash instead of array. Here is some benchmark:

use strict;
use warnings;

use Benchmark("timethese");

my $array;
for (1 .. 100_000) {
        push @$array, $_;
}
my $hash;
for (1 .. 100_000) {
        $hash->{$_} = 1;
}

timethese(1, {'array' => sub {s1($array)}, 'hash' => sub{s2($hash)}});

sub s1 {
    my $array = shift;
    for (my $i = 100_000; $i > 0; $i --) {
        splice(@$array, int(rand($i)), 1);
    }
}

sub s2 {
    my $hash = shift;
    for (my $i = 100_000; $i > 0; $i --) {
        delete($hash->{int(rand($i))});
    }
}
[download]

Result on my XP is:

Benchmark: timing 1 iterations of array, hash...
     array:  8 wallclock secs ( 7.38 usr +  0.00 sys =  7.38 CPU) @  0
+.14/s (n=1
)
            (warning: too few iterations for a reliable count)
      hash:  0 wallclock secs ( 0.20 usr +  0.00 sys =  0.20 CPU) @  4
+.93/s (n=1
)
            (warning: too few iterations for a reliable count)

C:\Perl\bin>perl -w math1.pl
Benchmark: timing 1 iterations of array, hash...
     array:  8 wallclock secs ( 7.44 usr +  0.00 sys =  7.44 CPU) @  0
+.13/s (n=1
)
            (warning: too few iterations for a reliable count)
      hash:  0 wallclock secs ( 0.25 usr +  0.00 sys =  0.25 CPU) @  4
+.00/s (n=1
)
            (warning: too few iterations for a reliable count)
[download]

(Update: the above solution using reverse is cooler and better than this one.

I would suggest using splice rather than delete for this purpose, but either way you're going to have to use something other than for over the array.

Like a lot of things the "three-part" or "C-style" for loop should be avoided in general, but used when needed. Don't feel that you must never use it.

my @foo = (1,2,2,1) x 5;
my @bar = (2) x 20;

for (my $i = 0; $i < @foo; $i++) {
  print "$i\n";
  if ($foo[$i] % $bar[$i]) {  
    splice @foo, $i, 1; $i--
  }
}

print "@foo\n";
[download]

Use splice

I was told that I shouldn't use the C format of using for (i.e. for ($i=0;$i<10;$i++) for replacing the array's elements but use perl's for/foreach command. That works fine...

use strict;

my @a = (1..20);
my @b = (2,3,13,14,17);

@a = do{my %i; undef @i{@a}; delete @i{@b}; sort {$a<=>$b} keys %i};
[download]

my %result=();
for ( @a, @b ) {
    if ( $result{ $_ } ) {
        delete $result{ $_ };
    }
    else {
        $result{ $_ } = 1;
    }
}
[download]