Pretty way to group elements at odd and even positions

Question

How to make a function that splits list elements by odd and even positions? Shortest implementation wins. I myself came up with:

splitOdds[x_] := 
 Extract[x, {#}\[Transpose]] & /@ GatherBy[Range@Length@x, OddQ]

And:

splitOdds[x_] := Flatten[Partition[#, 1, 2]] & /@ {x, Rest@x}

splitOdds[{a, b, c, d, e, f}]
(*{{a, c, e}, {b, d, f}}*)

You can use Span e.g. Range[10][[;; ;; 2]] and Range[10][[2 ;; ;; 2]] — Mr.Wizard, Mar 16 '13 at 12:04
The title and the text description of this question suggests something completely different. Further users will definitely be confused why you are not gathering even/odd elements, but elements on even/odd positions instead. — halirutan, Mar 16 '13 at 12:19
How about Part[A, #] & /@ GatherBy[Range@Length@lst, OddQ] — chyanog, Mar 16 '13 at 14:00

Mr.Wizard · Accepted Answer · 2013-03-16T12:58:45.040

22

A couple for fun:

lst = {a, b, c, d, e, f, g};

Partition[lst, 2, 2, 1, {}] ~Flatten~ {2}

{{a, c, e, g}, {b, d, f}}

i = 1; GatherBy[lst, i *= -1 &]

{{a, c, e, g}, {b, d, f}}

And my Golf entry:

lst[[# ;; ;; 2]] & /@ {1,2}

{{a, c, e, g}, {b, d, f}}

And here is an anti-Golf "Rube Goldberg" solution:

ReleaseHold[List @@ Dot @@ 
  PadRight[{Hold /@ lst, {}}, Automatic, #]] & /@
    Permutations[Range[1, 0, -1]]

{{a, c, e, g}, {b, d, f}}

edited Mar 16 '13 at 12:58

answered Mar 16 '13 at 12:11

Mr.Wizard

271,378
34
587
1,371

1

It's brilliant! – swish Mar 16 '13 at 12:21
@swish Thanks. :-) – Mr.Wizard Mar 16 '13 at 12:22
Alright. It would be hard to beat but let's see. – swish Mar 16 '13 at 12:27

score 21 · Answer 2 · edited Apr 13 '17 at 12:55

Less than sensible, more than pretty, hopefully enjoyable, with a different notion of grouping. Based in part on this question. Gives a new meaning to bubble sort.

Movie of grouping

list = {a, b, c, d, e, f, g(*, h, l, m, n, o, p, q, r, s, t*)};

likeElements[list_, {idx_}] /; OddQ[idx] := list[[1 ;; ;; 2]]; 
likeElements[list_, {idx_}] /; EvenQ[idx] := list[[2 ;; ;; 2]];
coords = Transpose[{Range[#], RandomReal[{-0.01, 0.01}, #], RandomReal[{-0.01, 0.01}, #]}] &@Length[list]; 

Dynamic[
 Refresh[Module[{d},
   Graphics3D[GraphicsComplex[
     coords -= MapIndexed[
       Total[Function[x, (d = # - x)/(d = Sqrt[d.d]) Log@d/2^(2 + 2 Sqrt[d])] /@ 
           Drop[likeElements[coords, #2], Ceiling[#2/2]]] + 
         Total[Function[x, -(d = # - x)/(d = Sqrt[d.d])^2 (d - 1/E) (1 - d/7)/2^(2 + 2 d)] /@ 
           likeElements[coords, #2 + 1]] &, coords],
    {MapIndexed[Text[Style[#1, ColorData[2][Mod[First[#2], 2]]], First[#2]] &, list],
     Opacity[0.3], Sphere[Range@Length[list], E^-1]}], 
    PlotRange -> {{-1.5, Length[list] + 1.5}, 4 {-1, 1}, 4 {-1, 1}}]
   ],
  UpdateInterval -> 1]]

Tweaking the coefficients slightly changes the behavior, which is also somewhat dependent on the length of the list. Won't win a speed contest.

The two Total[Function...] expressions calculate the new positions based on like elements (same parity) attract (first Total) and unlike repel (second Total).

score 17 · Answer 3 · edited Mar 16 '13 at 17:10

17

You can also use Downsample, which is new in version 9:

lst = {a, b, c, d, e, f, g};
Downsample[lst, 2, #] & /@ {1, 2}
(* {{a, c, e, g}, {b, d, f}} *)

edited Mar 16 '13 at 17:10

rm -rf

88,781
21
293
472

answered Mar 16 '13 at 15:02

Rojo

42,601
7
96
188

Oh neat, one new useful function learned. – swish Mar 16 '13 at 16:28
+1 Nice. I hadn't found Downsample yet. – Michael E2 Mar 16 '13 at 16:28
Is this function any faster than Part and Span, or Take? – Mr.Wizard Mar 17 '13 at 06:58
@Mr.Wizard in my quick test, MMA 9.0.1, for packed arrays, better to worse, Downsample- Part- Take, but not for much. For unpacked, the opposite order – Rojo Mar 17 '13 at 08:01
Thanks. It sounds like my old friend Part is still a good universal choice. :-) – Mr.Wizard Mar 17 '13 at 08:04

score 13 · Answer 4 · answered Mar 16 '13 at 14:54

13

Since all the sensible answers have already been done...

lst ~(•=#;Cases)~(_/;(•=!•))&/@{!#,#}&[_==_]

answered Mar 16 '13 at 14:54

Simon Woods

84,945
8
175
324

Oh great! Now this is going to start an obfuscated mma trend! – rm -rf Mar 16 '13 at 15:02
This is really great. It's not often I have to do a double-take on syntax. :-O – Mr.Wizard Mar 16 '13 at 15:26
1

Will it rm -rf /* my disk? :) – swish Mar 16 '13 at 16:31
1

@swish I promise to not do anything to your disk ;) – rm -rf Mar 16 '13 at 17:12
Ok, you've just got my wtf, I mean +1. I still haven't parsed it ... – rcollyer Mar 16 '13 at 22:17

score 10 · Answer 5 · answered Mar 16 '13 at 12:38

10

My way:

lst = {a, b, c, d, e, f, g};    

Take[lst, {#, -1, 2}] & /@ {1, 2}

{{a, c, e, g}, {b, d, f}}

answered Mar 16 '13 at 12:38

VLC

9,818
1
31
60

That's mine, just longer. :-p – Mr.Wizard Mar 16 '13 at 12:43
@Mr.Wizard Ha, I've just seen now that in the docs for Span it says m[[i;;j;;k]] is equivalent to Take[m,{i,j,k}]. Well, let's say that mine is more readable for novice users. – VLC Mar 16 '13 at 12:49
Indeed it is. I'm just poking fun. :-) – Mr.Wizard Mar 16 '13 at 12:54
By the way, try your hand at a "Rube Goldberg" solution. I had fun with mine, though it could be considerably more complicated... – Mr.Wizard Mar 16 '13 at 12:55
I just timed these and Take is slightly faster. +1 for pragmatism. – Mr.Wizard Mar 16 '13 at 13:08
How about also adding Drop method to it for completion? – swish Mar 16 '13 at 19:06
@swish you mean like: lst ~#~ {1, -1, 2}] & /@ {Take, Drop}? – Mr.Wizard Mar 19 '13 at 03:29
@Mr.Wizard No, I meant Drop[lst, {#, -1, 2}] & /@ {2, 1}. Basically replace Take with Drop. – swish Mar 19 '13 at 13:44

score 6 · Answer 6 · answered Mar 16 '13 at 13:36

6

Here is another one, based on Reap and Sow:

Reap[MapIndexed[Sow[#1, Mod[#2, 2]] &, lst], _, #2 &][[2]]

This one has an advantage to be easily generalizable to more complex conditions, although certainly not the fastest one here.

answered Mar 16 '13 at 13:36

Leonid Shifrin

114,335
15
329
420

That looks too complicated. I would write: Reap[# ~Sow~ Mod[#2, 2] & ~MapIndexed~ lst][[2]] – Mr.Wizard Mar 16 '13 at 13:54
@Mr.Wizard Yes, you can skip the pattern on Reap. But, generally, I am in the habit of keeping it, since I often use Reap with some tags just for safety. – Leonid Shifrin Mar 16 '13 at 14:25

score 6 · Answer 7 · answered Mar 16 '13 at 21:08

I'll join in with my own version:

splitList[list_] := Pick[list, 
    IntegerDigits[1/6 (-3 - (-1)^#1 + 2^(2 + #1)) &@Length@list, 2], #] & /@ {1, 0}

splitList[{a, b, c, d, e, f, g}]
(* {{a, c, e, g}, {b, d, f}} *)

This uses the fact that the "selector pattern" or "sieve" for the elements proceeds as

$$1, 10, 101, 1010, 10101,... $$

and the general term (in base 10) for the binary sequence above is $\frac{1}{6}(2^{2+n}-(-1)^n-3)$, where $n$ is the length of your list.

The selector pattern can also be generated more straightforwardly as:

Riffle[ConstantArray[1, Ceiling[Length@list/2]], 0]

Equivalently: splitList[l_List] := With[{n = Length[l]}, Pick[l, IntegerDigits[Ceiling[2 (2^n - 1)/3], 2, n], #] & /@ {1, 0}] — J. M.'s missing motivation, May 06 '13 at 06:24

DavidC · Answer 8 · 2013-03-17T01:43:22.760

Method 1: GatherBy each element's position (even or odd).

GatherBy[lst, Mod[Position[lst,#],2]&]

{{a, c, e, g}, {b, d, f}}

Method 2: Using ArrayReshape (version 9).

Mathematica graphics

In the following, the MathematicaIcon is used for padding in the reshaping of the array. After the array is reshaped, the icons are removed. Any element can be used in lieu of the MathematicaIcon, provide that one is certain that the padding element is not in the original list.

 ArrayReshape[lst,{Length[lst],2},"\[MathematicaIcon]"]\[Transpose]
 /."\[MathematicaIcon]"->Sequence[]

Method 3: Check whether each index from MapIndexed is even or odd.

GatherBy[MapIndexed[List,lst],OddQ]/.{x_,{_}}:> x

Michael E2 · Answer 9 · 2013-03-17T12:23:14.093

4

Base on Pick:

gather[list_] := Pick[{list, list}, Take[#, Length@list] & /@ {#, RotateLeft[#]} &@
  Mod[Range@Ceiling[Length@list, 2], 2], 1];

gather[{a, b, c, d, e, f, g}]

{{a, c, e, g}, {b, d, f}}

edited Mar 17 '13 at 12:23

answered Mar 16 '13 at 14:18

Michael E2

235,386
17
334
747

g is in both your output lists! – DavidC Mar 17 '13 at 04:26

chyanog · Answer 10 · 2013-03-16T14:50:45.753

2

# & @@@ # & /@ GatherBy[MapIndexed[{#, OddQ@#2} &, lst], Last]
#[[All, 1]] & /@ GatherBy[MapIndexed[{#, OddQ@#2} &, lst], Last]

edited Mar 16 '13 at 14:50

answered Mar 16 '13 at 14:09

chyanog

15,542
3
40
78

score 0 · Answer 11 · answered Nov 05 '21 at 16:31

0

This is how i do it:

GetEvenStep[list_] := Partition[list, 2][[All, 1]]

GetOddStep[list_] := Partition[list, 2][[All, 2]]

Be careful, depending on the list you want to split you might want to flip the names!

answered Nov 05 '21 at 16:31

Guglielmo Ferranti

1

Pretty way to group elements at odd and even positions

11 Answers11

Linked

Related