What is the best way to delete a value from an array in Perl

Question

The array has lots of data and I need to delete two elements    Below is the code snippet I am using   my  array    1 2 3 4 5 5 6 5 4 9   my  element omitted   5   array   grep          element omitted    array

User · Answer

Just to be sure I have benchmarked grep and map solutions, first searching for indexes of matched elements (those to remove) and then directly removing the elements by grep without searching for the indexes. I appears that the first solution proposed by Sam when asking his question was already the fastest.

    use Benchmark;
    my @A=qw(A B C A D E A F G H A I J K L A M N);
    my @M1; my @G; my @M2;
    my @Ashrunk;
    timethese( 1000000, {
      'map1' => sub {
          my $i=0;
          @M1 = map { $i++; $_ eq 'A' ? $i-1 : ();} @A;
      },
      'map2' => sub {
          my $i=0;
          @M2 = map { $A[$_] eq 'A' ? $_ : () ;} 0..$#A;
      },
      'grep' => sub {
          @G = grep { $A[$_] eq 'A' } 0..$#A;
      },
      'grem' => sub {
          @Ashrunk = grep { $_ ne 'A' } @A;
      },
    });

The result is:

Benchmark: timing 1000000 iterations of grem, grep, map1, map2...
  grem:  4 wallclock secs ( 3.37 usr +  0.00 sys =  3.37 CPU) @ 296823.98/s (n=1000000)
  grep:  3 wallclock secs ( 2.95 usr +  0.00 sys =  2.95 CPU) @ 339213.03/s (n=1000000)
  map1:  4 wallclock secs ( 4.01 usr +  0.00 sys =  4.01 CPU) @ 249438.76/s (n=1000000)
  map2:  2 wallclock secs ( 3.67 usr +  0.00 sys =  3.67 CPU) @ 272702.48/s (n=1000000)
M1 = 0 3 6 10 15
M2 = 0 3 6 10 15
G = 0 3 6 10 15
Ashrunk = B C D E F G H I J K L M N

As shown by elapsed times, it's useless to try to implement a remove function using either grep or map defined indexes. Just grep-remove directly.

Before testing I was thinking "map1" would be the most efficient... I should more often rely on Benchmark I guess. ;-)

User · Answer

If you know the array index  you can delete   it   The difference between splice   and delete   is that delete   does not renumber the remaining elements of the array

User · Answer

I think your solution is the simplest and most maintainable   The rest of the post documents the difficulty of turning tests on elements into splice offsets  Thus  making it a more complete answer    Look at the gyrations you have to go through to have an efficient  i e  one-pass  algorithm to turn tests on list items into indexes  And it s not that intuitive at all    sub array remove      amp           my    arr ref   test block             my  sp start    0      my  sp len      0      for   my  inx   0   inx  lt      arr ref   inx               local       arr ref- gt   inx           next unless  test block- gt                 if    sp len  gt  0  amp  amp   inx  gt   sp start    sp len                 splice    arr ref   sp start   sp len                 inx       inx -  sp len               sp len   0                     sp start    inx if    sp len    1            splice    arr ref   sp start   sp len   if  sp len  gt  0      return

User · Answer

Is this something you are going to be doing a lot   If so  you may want to consider a different data structure   Grep is going to search the entire array every time and for a large array could be quite costly   If speed is an issue then you may want to consider using a Hash instead   In your example  the key would be the number and the value would be the count of elements of that number

User · Answer

Use splice if you already know the index of the element you want to delete   Grep works if you are searching   If you need to do a lot of these  you will get much better performance if you keep your array in sorted order  since you can then do binary search to find the necessary index   If it makes sense in your context  you may want to consider using a  magic value  for deleted records  rather then deleting them  to save on data movement -- set deleted elements to undef  for example   Naturally  this has its own issues  if you need to know the number of  live  elements  you need to keep track of it separately  etc   but may be worth the trouble depending on your application   Edit Actually now that I take a second look -- don t use the grep code above  It would be more efficient to find the index of the element you want to delete  then use splice to delete it  the code you have accumulates all the non-matching results     my  index   0   index   until  arr  index  eq  foo   splice  arr   index  1     That will delete the first occurrence  Deleting all occurrences is very similar  except you will want to get all indexes in one pass   my  del indexes   grep    arr     eq  foo    0    arr    The rest is left as an excercise for the reader -- remember that the array changes as you splice it   Edit2 John Siracusa correctly pointed out I had a bug in my example   fixed  sorry about that

User · Answer

I think your solution is the simplest and most maintainable   The rest of the post documents the difficulty of turning tests on elements into splice offsets  Thus  making it a more complete answer    Look at the gyrations you have to go through to have an efficient  i e  one-pass  algorithm to turn tests on list items into indexes  And it s not that intuitive at all    sub array remove      amp           my    arr ref   test block             my  sp start    0      my  sp len      0      for   my  inx   0   inx  lt      arr ref   inx               local       arr ref- gt   inx           next unless  test block- gt                 if    sp len  gt  0  amp  amp   inx  gt   sp start    sp len                 splice    arr ref   sp start   sp len                 inx       inx -  sp len               sp len   0                     sp start    inx if    sp len    1            splice    arr ref   sp start   sp len   if  sp len  gt  0      return

User · Answer

A similar code I once wrote to remove strings not starting with SB 1 from an array of strings  my  adoSymbols   SB 1000   RT 10000   PC 10000      Remove items from an array from backward for my  i   adoSymbols  i gt  0  i--          unless   adoSymbols  i     m  SB  1    splice  adoSymbols  i 1

User · Answer

Is this something you are going to be doing a lot   If so  you may want to consider a different data structure   Grep is going to search the entire array every time and for a large array could be quite costly   If speed is an issue then you may want to consider using a Hash instead   In your example  the key would be the number and the value would be the count of elements of that number

User · Answer

I use   delete  array  index     Perldoc delete

User · Answer

Delete all occurrences of  something  if array   Based on SquareCog answer s   my  arr     1   2   3   4   3   2    3   4   3    my  dix   grep    arr     eq  4    0    arr  my  o   0  for   dix        splice  arr    - o  1        o      print join   n    arr     Each time we remove index from  arr  the next correct index to delete will be   -current loop step

User · Answer

splice will remove array element s  by index   Use grep  as in your example  to search and remove

User · Answer

If you know the array index  you can delete   it   The difference between splice   and delete   is that delete   does not renumber the remaining elements of the array

User · Answer

Is this something you are going to be doing a lot   If so  you may want to consider a different data structure   Grep is going to search the entire array every time and for a large array could be quite costly   If speed is an issue then you may want to consider using a Hash instead   In your example  the key would be the number and the value would be the count of elements of that number

User · Answer

Delete all occurrences of  something  if array   Based on SquareCog answer s   my  arr     1   2   3   4   3   2    3   4   3    my  dix   grep    arr     eq  4    0    arr  my  o   0  for   dix        splice  arr    - o  1        o      print join   n    arr     Each time we remove index from  arr  the next correct index to delete will be   -current loop step

User · Answer

Use splice if you already know the index of the element you want to delete   Grep works if you are searching   If you need to do a lot of these  you will get much better performance if you keep your array in sorted order  since you can then do binary search to find the necessary index   If it makes sense in your context  you may want to consider using a  magic value  for deleted records  rather then deleting them  to save on data movement -- set deleted elements to undef  for example   Naturally  this has its own issues  if you need to know the number of  live  elements  you need to keep track of it separately  etc   but may be worth the trouble depending on your application   Edit Actually now that I take a second look -- don t use the grep code above  It would be more efficient to find the index of the element you want to delete  then use splice to delete it  the code you have accumulates all the non-matching results     my  index   0   index   until  arr  index  eq  foo   splice  arr   index  1     That will delete the first occurrence  Deleting all occurrences is very similar  except you will want to get all indexes in one pass   my  del indexes   grep    arr     eq  foo    0    arr    The rest is left as an excercise for the reader -- remember that the array changes as you splice it   Edit2 John Siracusa correctly pointed out I had a bug in my example   fixed  sorry about that

User · Answer

I think your solution is the simplest and most maintainable   The rest of the post documents the difficulty of turning tests on elements into splice offsets  Thus  making it a more complete answer    Look at the gyrations you have to go through to have an efficient  i e  one-pass  algorithm to turn tests on list items into indexes  And it s not that intuitive at all    sub array remove      amp           my    arr ref   test block             my  sp start    0      my  sp len      0      for   my  inx   0   inx  lt      arr ref   inx               local       arr ref- gt   inx           next unless  test block- gt                 if    sp len  gt  0  amp  amp   inx  gt   sp start    sp len                 splice    arr ref   sp start   sp len                 inx       inx -  sp len               sp len   0                     sp start    inx if    sp len    1            splice    arr ref   sp start   sp len   if  sp len  gt  0      return

User · Answer

You can use the non-capturing group and a pipe delim list of items to remove    perl -le   ar  1    20   x  8 10 3 17   x join      x   ar grep        x   o   ar print   ar

User · Answer

splice will remove array element s  by index   Use grep  as in your example  to search and remove

User · Answer

if you change  my  del indexes   grep    arr     eq  foo    0    arr    to   my  del indexes   reverse grep    arr     eq  foo    0    arr     This avoids the array renumbering issue by removing elements from the back of the array first  Putting a splice   in a foreach loop cleans up  arr  Relatively simple and readable     foreach  item   del indexes       splice   arr  item 1

User · Answer

The best I found was a combination of  undef  and  grep    foreach  index    list of indexes to be skiped           undef  array  index       array   grep   defined        array    That does the trick  Federico

User · Answer

The best I found was a combination of  undef  and  grep    foreach  index    list of indexes to be skiped           undef  array  index       array   grep   defined        array    That does the trick  Federico

User · Answer

You can simply do this   my  input Color    Green   my  array   qw Red Blue Green Yellow Black    array   grep     input Color    array  print   array

User · Answer

Use splice if you already know the index of the element you want to delete   Grep works if you are searching   If you need to do a lot of these  you will get much better performance if you keep your array in sorted order  since you can then do binary search to find the necessary index   If it makes sense in your context  you may want to consider using a  magic value  for deleted records  rather then deleting them  to save on data movement -- set deleted elements to undef  for example   Naturally  this has its own issues  if you need to know the number of  live  elements  you need to keep track of it separately  etc   but may be worth the trouble depending on your application   Edit Actually now that I take a second look -- don t use the grep code above  It would be more efficient to find the index of the element you want to delete  then use splice to delete it  the code you have accumulates all the non-matching results     my  index   0   index   until  arr  index  eq  foo   splice  arr   index  1     That will delete the first occurrence  Deleting all occurrences is very similar  except you will want to get all indexes in one pass   my  del indexes   grep    arr     eq  foo    0    arr    The rest is left as an excercise for the reader -- remember that the array changes as you splice it   Edit2 John Siracusa correctly pointed out I had a bug in my example   fixed  sorry about that

User · Answer

You could use array slicing instead of splicing   Grep to return the indices you want keep and use slicing  my  arr          run through each item  my  indicesToKeep   grep    arr     ne  foo    0    arr   arr    arr  indicesToKeep

User · Answer

You can use the non-capturing group and a pipe delim list of items to remove    perl -le   ar  1    20   x  8 10 3 17   x join      x   ar grep        x   o   ar print   ar

User · Answer

If you know the array index  you can delete   it   The difference between splice   and delete   is that delete   does not renumber the remaining elements of the array

User · Answer

If you know the array index  you can delete   it   The difference between splice   and delete   is that delete   does not renumber the remaining elements of the array

User · Answer

if you change  my  del indexes   grep    arr     eq  foo    0    arr    to   my  del indexes   reverse grep    arr     eq  foo    0    arr     This avoids the array renumbering issue by removing elements from the back of the array first  Putting a splice   in a foreach loop cleans up  arr  Relatively simple and readable     foreach  item   del indexes       splice   arr  item 1

User · Answer

I think your solution is the simplest and most maintainable   The rest of the post documents the difficulty of turning tests on elements into splice offsets  Thus  making it a more complete answer    Look at the gyrations you have to go through to have an efficient  i e  one-pass  algorithm to turn tests on list items into indexes  And it s not that intuitive at all    sub array remove      amp           my    arr ref   test block             my  sp start    0      my  sp len      0      for   my  inx   0   inx  lt      arr ref   inx               local       arr ref- gt   inx           next unless  test block- gt                 if    sp len  gt  0  amp  amp   inx  gt   sp start    sp len                 splice    arr ref   sp start   sp len                 inx       inx -  sp len               sp len   0                     sp start    inx if    sp len    1            splice    arr ref   sp start   sp len   if  sp len  gt  0      return

User · Answer

splice will remove array element s  by index   Use grep  as in your example  to search and remove

User · Answer

Is this something you are going to be doing a lot   If so  you may want to consider a different data structure   Grep is going to search the entire array every time and for a large array could be quite costly   If speed is an issue then you may want to consider using a Hash instead   In your example  the key would be the number and the value would be the count of elements of that number

User · Answer

Just to be sure I have benchmarked grep and map solutions, first searching for indexes of matched elements (those to remove) and then directly removing the elements by grep without searching for the indexes. I appears that the first solution proposed by Sam when asking his question was already the fastest.

    use Benchmark;
    my @A=qw(A B C A D E A F G H A I J K L A M N);
    my @M1; my @G; my @M2;
    my @Ashrunk;
    timethese( 1000000, {
      'map1' => sub {
          my $i=0;
          @M1 = map { $i++; $_ eq 'A' ? $i-1 : ();} @A;
      },
      'map2' => sub {
          my $i=0;
          @M2 = map { $A[$_] eq 'A' ? $_ : () ;} 0..$#A;
      },
      'grep' => sub {
          @G = grep { $A[$_] eq 'A' } 0..$#A;
      },
      'grem' => sub {
          @Ashrunk = grep { $_ ne 'A' } @A;
      },
    });

The result is:

Benchmark: timing 1000000 iterations of grem, grep, map1, map2...
  grem:  4 wallclock secs ( 3.37 usr +  0.00 sys =  3.37 CPU) @ 296823.98/s (n=1000000)
  grep:  3 wallclock secs ( 2.95 usr +  0.00 sys =  2.95 CPU) @ 339213.03/s (n=1000000)
  map1:  4 wallclock secs ( 4.01 usr +  0.00 sys =  4.01 CPU) @ 249438.76/s (n=1000000)
  map2:  2 wallclock secs ( 3.67 usr +  0.00 sys =  3.67 CPU) @ 272702.48/s (n=1000000)
M1 = 0 3 6 10 15
M2 = 0 3 6 10 15
G = 0 3 6 10 15
Ashrunk = B C D E F G H I J K L M N

As shown by elapsed times, it's useless to try to implement a remove function using either grep or map defined indexes. Just grep-remove directly.

Before testing I was thinking "map1" would be the most efficient... I should more often rely on Benchmark I guess. ;-)

User · Answer

Use splice if you already know the index of the element you want to delete   Grep works if you are searching   If you need to do a lot of these  you will get much better performance if you keep your array in sorted order  since you can then do binary search to find the necessary index   If it makes sense in your context  you may want to consider using a  magic value  for deleted records  rather then deleting them  to save on data movement -- set deleted elements to undef  for example   Naturally  this has its own issues  if you need to know the number of  live  elements  you need to keep track of it separately  etc   but may be worth the trouble depending on your application   Edit Actually now that I take a second look -- don t use the grep code above  It would be more efficient to find the index of the element you want to delete  then use splice to delete it  the code you have accumulates all the non-matching results     my  index   0   index   until  arr  index  eq  foo   splice  arr   index  1     That will delete the first occurrence  Deleting all occurrences is very similar  except you will want to get all indexes in one pass   my  del indexes   grep    arr     eq  foo    0    arr    The rest is left as an excercise for the reader -- remember that the array changes as you splice it   Edit2 John Siracusa correctly pointed out I had a bug in my example   fixed  sorry about that

User · Answer

I use   delete  array  index     Perldoc delete

User · Answer

splice will remove array element s  by index   Use grep  as in your example  to search and remove

User · Answer

A similar code I once wrote to remove strings not starting with SB 1 from an array of strings  my  adoSymbols   SB 1000   RT 10000   PC 10000      Remove items from an array from backward for my  i   adoSymbols  i gt  0  i--          unless   adoSymbols  i     m  SB  1    splice  adoSymbols  i 1

User · Answer

You could use array slicing instead of splicing   Grep to return the indices you want keep and use slicing  my  arr          run through each item  my  indicesToKeep   grep    arr     ne  foo    0    arr   arr    arr  indicesToKeep

User · Answer

You can simply do this   my  input Color    Green   my  array   qw Red Blue Green Yellow Black    array   grep     input Color    array  print   array

[arrays] What is the best way to delete a value from an array in Perl?

Examples related to arrays

Examples related to perl