Drop elements from list

Dear group,

Consider a list of length, say, 20:

a = RandomReal[{},20];

How would you then drop/delete elements, say, 2-5 and 7-10 from this
list? The built-in function Drop does not seem to include such a
possibility. I should add that I do not have access to Mathematica 7,
so any solution should work in version 6.

Kind regards,
Sigmund

Sigmund,
if L denotes a list of pairwise disjoint intervals  a folded Drop
solves the problem:

Fold[Drop[#1, #2] &, a, Reverse@Sort[L]]

Test:

In[3]:= L = {{2, 5}, {7, 10}}; Fold[Drop[#1, #2] & , 100 + Range[20],
Reverse[Sort[L]]]

Out[3]= {101, 106, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120}

Adriano Pascoletti

2008/12/6 SigmundV < XXXX@XXXXX.COM >:

There are many ways to do this; probably the fastest and most flexible
method would be:

x = Complement[ Range[Length[a]], Range[2,5], Range[7, 10] ];
a[[x]]

Hi,

a = Table[b[i], {i, 20}];

and

Drop[Drop[a, {7, 10}], {2, 5}]

and it works ..

Regards
  Jens

a = Array[x, {20}];

Drop[Drop[a, {7, 10}], {2, 5}]

{x(1),x(6),x(11),x(12),x(13),x(14),x(15),x(16),x(17),x(18),x(19),x(20)}

Fold[Drop[#1, #2] &, a, {{7, 10}, {2, 5}}]

{x(1),x(6),x(11),x(12),x(13),x(14),x(15),x(16),x(17),x(18),x(19),x(20)}

Or slightly more succinctly with Fold

Fold[Drop[##] &, a, {{7, 10}, {2, 5}}]

{x(1),x(6),x(11),x(12),x(13),x(14),x(15),x(16),x(17),x(18),x(19),x(20)}

% == %% == %%%

True


Bob Hanlon




=============
Dear group,

Consider a list of length, say, 20:

a = RandomReal[{},20];

How would you then drop/delete elements, say, 2-5 and 7-10 from this
list? The built-in function Drop does not seem to include such a
possibility. I should add that I do not have access to Mathematica 7,
so any solution should work in version 6.

Kind regards,
Sigmund

Hello,

In[33]:=
lst = Table[Random[Integer, {1, 10}], {20}]

Out[33]=
{7,8,9,5,3,2,5,10,7,8,4,7,6,6,9,7,8,7,6,9}

In[34]:=
lst[[Flatten[{1, 6, Range[10, 20]}]]]

Out[34]=
{7,2,8,4,7,6,6,9,7,8,7,6,9}

I'm surprised no one mentioned Delete, as in

Delete[a, Transpose@Flatten@{Range[2,5],Range[7,10]} ].

Thank you for all the solutions. Some of them I should have come up
with myself. My favorite is probably Fold[Drop[##]&,a,{{7,10},{2,5}}].
I don't know whether it is the fastest or not, but it is easy to
program (as in "characters to type"). Ray Koopman's solution with
Delete is also good (although I would like to point out that
Transpose@Flatten@{Range[2,5],Range[7,10]} does not work as it is, but
Partition[...,1] does the trick) and easy to program as well. The idea
presented by Raffy and dimitris, to pick the relevant elements instead
of deleting, is also good. I have discovered that it generally is
faster to pick explicit elements from a list than to use functions as
Drop or Delete. In that respect I like Raffy's solution, but it seems
that too much time is spent in Complement.

Finally, below is a cell with timings of the different solutions. I
would like to hear your comments on this. The final line is included
to see how much time is spent in Complement.

a = RandomReal[{}, 2000000];
Delete[a, Partition[Range[2, 5]~Join~Range[7, 10]~Join~Range[15, 18],
1]]; // Timing
a[[{1, 6}~Join~Range[11, 14]~Join~Range[19, Length[a]]]]; // Timing
Fold[Drop[##] &, a, {{15, 18}, {7, 10}, {2, 5}}]; // Timing
a[[Complement[Range[Length[a]], Range[2, 5], Range[7, 10], Range[15,
18]]]]; // Timing
Complement[Range[Length[a]], Range[2, 5], Range[7, 10], Range[15,
18]]; // Timing

/Sigmund

I omitted a pair of curly brackets. I meant to write
  Transpose@{Flatten@{Range[2,5],Range[7,10]}}.


a = RandomReal[{}, 2*^7];
b1 = Delete[a, Partition[Join[Range[2,5],Range[7,10],
                              Range[15,18]],1]]; // Timing
b2 = a[[Join[{1,6},Range[11,14],Range[19,Length@a]]]]; // Timing
b3 = Fold[Drop[##]&, a, {{15,18},{7,10},{2,5}}]; // Timing
b4 = a[[Complement[Range@Length@a, Range[2,5],Range[7,10],
                                   Range[15,18]]]]; // Timing
b5 = a[[komplement[Length@a, Join[Range[2,5],Range[7,10],
                                  Range[15,18]]]]]; // Timing
SameQ[b1,b2,b3,b4,b5]
c1 = Complement[Range@Length@a, Range[2,5],Range[7,10],
                                Range[15,18]]; // Timing
c2 = komplement[Length@a, Join[Range[2,5],Range[7,10],
                                Range[15,18]]]; // Timing
SameQ[c1,c2]

{0.55,Null}
{1.88,Null}
{1.81,Null}
{8.91,Null}
{3.65,Null}
True
{7.81,Null}
{2.,Null}
True

If your lists will usually be so long, with so few elements to
be deleted, it looks like deleting will be faster than taking.

Correcting an omission from my previous post:




Here's an adaptation of Carl Woll's "missing" from his July 15, 2005,
post in the thread "Complement replacement":

komplement[n_, list_] := Block[{r = Range@n}, r[[list]] = 0;
           SparseArray[r] /. SparseArray[_,_,_,x_]:>x[[3]]]

It's not really a fair comparison, as only the Complement can handle
any combination of ranges, even malformed ranges.
Delete/Partition solution comes close, but still will fail if you give
it malformed range.
The other solutions suggested require that the ranges are non-
overlapping, reverse sorted, and well-formed.

To have the benefit of being able to give the Fold/Drop solution with
any combination of well-formed ranges, you could do:

ranges = { Range[2,5], Range[7,10], Range[15, 18] };

Fold[Drop, a, Reverse[Split[Union @@ ranges, #2 - #1 == 1 &][[All, {1,
-1}]]]]

ie. this would let you do something like: { Range[2, 10], Range[3,
11], Range[15,18] };