However, it's much easier and more efficient to create a new array instead of splicing the same array, since each splice needs to copy all the elements from $i to the end of the array rearrange/copy the pointers to the elements from element $i to the end of the array.

my @newarray;
foreach my $i (@arrayindex) {
   push @newarray,$array[$i];
}
[download]

Another way would be to use grep (if you can determine which elements to keep based solely on their value):

my @kept = grep { $_ < 4 and $_ > 10 } @array;
[download]

@array = grep { $_ < 4 and $_ > 10 } @array;
[download]

... since each splice needs to copy all the elements from $i to the end of the array.

Is that so? I always thought of splice being highly efficient, working "in-place", just "re-arranging elements", without need to copy anything. Can you ascertain your statement?

--shmem

_($_=" "x(1<<5)."?\n".q·/)Oo.  G°\        /
                              /\_¯/(q    /
----------------------------  \__(m.====·.(_("always off the crowd"))."·
");sub _{s./.($e="'Itrs `mnsgdq Gdbj O`qkdq")=~y/"-y/#-z/;$e.e && print}

My bad, I should have been a little more careful. Perl arrays are just c-style arrays of pointers.

That means perl needs to re-arrange the pointers after each splice.

"What should it profit a man, if he should win a flame war, yet lose his cool?"

Ummm... you do realize that, while a valid example, nothing can ever be less than 4 AND greater than 10?

array = grep { $_ > 4 and $_ < 10 } @array;
[download]

                - Ant
                - Some of my best work - (1 2 3)

No I did not notice that :-)
"What should it profit a man, if he should win a flame war, yet lose his cool?"

Thank you Joost.

I am interested in the array that is left after removing/splicing out 
+the indices (defined in @arrayindex) from @array.

But, I have got an idea from your hint. Let's see.
Thanks.
[download]

Just do it from the back.

foreach my $i (reverse @arrayindex) {
  splice @array, $i, 1;
}
[download]

lodin

Update: This assumes sorted indexes. See GrandFather's note if they're not sorted.

assuming of course that the indexes are sorted in ascending order. Safer is:

foreach my $i (sort {$b <=> $a} @arrayindex) {
  splice @array, $i, 1;
}
[download]

which sorts in descending order thus guaranteeing the indexes are sorted, and removing the need for the reverse.

---

DWIM is Perl's answer to Gödel

Assuming of course that there are no duplicate indexes. Super-safest is:

foreach my $i (sort { $b <=> $a } unique(@arrayindex)) {
  splice @array, $i, 1;
}
[download]

;-)

lodin

my %indexHash;
my $ix =0;
foreach (@arrayindex){
  $indexHash{$_}=1};
my @cleansedArray =
  map { $indexHash($ix++) ? $_ : ()} @array
[download]

While many answers have been given above, every one of them is a quadratic-time solution (Update: Oops! didn't see throop's solution, which is also linear time as pointed out by ikegami. I guess I was writing while throop was posting.). The first removal shifts the top elements of the array down by 1. The next shifts more (including shifting the same previous elements once again), ...). On the other hand these operations are fast enough, that clarity and elegance of code may be reasons enough to not worry about efficiency.

While not as elegant as the previous entries, here is a linear time solution (I am assuming that @arrayindex is a reverse sorted & unique'd list. If not, use Grandfather's technique in Re^4: Remove array elements dynamically! (reverse)). At the end of the loop, the answer is stored in @newarray and @array is empty.

my @newarray = ();
foreach my $i (@arrayindex)
{ unshift @newarray, (splice @array, $i);
  pop @array;
}
[download]

While many answers have been given above, every one of them is a quadratic-time solution

Great solution, but throop's hash solution is linear like yours.

@array = (1..10);
for(my $i=0; $i<@array; $i++) {
  if($array[$i]%2) {
    splice(@array,$i,1,());
    $i-- #array is one shorter, now;
  }
}

print "@array\n";
[download]

delete @array[@arrayindex];
[download]

Note that deleting an array slice does not remove elements that aren't at the end of the array - it just sets them to undef.
"What should it profit a man, if he should win a flame war, yet lose his cool?"

Hello FunkyMonk,

Thanks for your reply. I understand "delete" function simply removes t
+he value and does not change the index. However, what I want is to re
+move the value along with its index (like what splice function does).
+ Thus imho, I guess delete will not help here? Any other solution? Th
+anks,

delete @array[@arrayindex];
[download]

It may be too inefficient if your arrays are large, but it does what you ask.

my @array = 1 .. 10;
my @arrayindex = ( 2, 6, 4, 5 );

splice @array, $_, 1 for sort { $b <=> $a } @arrayindex;

print "@array\n"; # 1 2 4 8 9 10
[download]

Thanks to Joost and newbio for pointing out that an aray slice doesn't delete elements not at the end of an array.

my @keep = (0..$#array);
$keep[$_] = undef
  for (@arrayindex);

@array = @array[grep {defined $_} @keep];
[download]