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, Commented Mar 16, 2013 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, Commented Mar 16, 2013 at 12:19
How about Part[A, #] & /@ GatherBy[Range@Length@lst, OddQ] — chyanog, Commented Mar 16, 2013 at 14:00

Mr.Wizard · Accepted Answer · 2013-03-16 12:58:45Z

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, 2013 at 12:58

answered Mar 16, 2013 at 12:11

Mr.Wizard

273k34 gold badges595 silver badges1.4k bronze badges

1

$\begingroup$ It's brilliant! $\endgroup$
– swish
Commented Mar 16, 2013 at 12:21
$\begingroup$ @swish Thanks. :-) $\endgroup$
– Mr.Wizard
Commented Mar 16, 2013 at 12:22
$\begingroup$ Alright. It would be hard to beat but let's see. $\endgroup$
– swish
Commented Mar 16, 2013 at 12:27

Add a comment |

Community · Accepted Answer · 2017-04-13 12:55:51Z

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).

rm -rf · Accepted Answer · 2013-03-16 17:10:51Z

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, 2013 at 17:10

rm -rf♦

89.3k21 gold badges296 silver badges479 bronze badges

answered Mar 16, 2013 at 15:02

Rojo

42.8k7 gold badges98 silver badges190 bronze badges

$\begingroup$ Oh neat, one new useful function learned. $\endgroup$
– swish
Commented Mar 16, 2013 at 16:28
$\begingroup$ +1 Nice. I hadn't found Downsample yet. $\endgroup$
– Michael E2
Commented Mar 16, 2013 at 16:28
$\begingroup$ Is this function any faster than Part and Span, or Take? $\endgroup$
– Mr.Wizard
Commented Mar 17, 2013 at 6:58
$\begingroup$ @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 $\endgroup$
– Rojo
Commented Mar 17, 2013 at 8:01
$\begingroup$ Thanks. It sounds like my old friend Part is still a good universal choice. :-) $\endgroup$
– Mr.Wizard
Commented Mar 17, 2013 at 8:04

Add a comment |

Simon Woods · Accepted Answer · 2013-03-16 14:54:36Z

14

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

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

answered Mar 16, 2013 at 14:54

Simon Woods

85.4k8 gold badges180 silver badges326 bronze badges

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

$\begingroup$ Will it rm -rf /* my disk? :) $\endgroup$
– swish
Commented Mar 16, 2013 at 16:31
1

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

Add a comment |

VLC · Accepted Answer · 2013-03-16 12:38:27Z

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, 2013 at 12:38

VLC

9,8781 gold badge32 silver badges60 bronze badges

$\begingroup$ That's mine, just longer. :-p $\endgroup$
– Mr.Wizard
Commented Mar 16, 2013 at 12:43
$\begingroup$ @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. $\endgroup$
– VLC
Commented Mar 16, 2013 at 12:49
$\begingroup$ Indeed it is. I'm just poking fun. :-) $\endgroup$
– Mr.Wizard
Commented Mar 16, 2013 at 12:54
$\begingroup$ By the way, try your hand at a "Rube Goldberg" solution. I had fun with mine, though it could be considerably more complicated... $\endgroup$
– Mr.Wizard
Commented Mar 16, 2013 at 12:55
$\begingroup$ I just timed these and Take is slightly faster. +1 for pragmatism. $\endgroup$
– Mr.Wizard
Commented Mar 16, 2013 at 13:08

| Show 3 more comments

rm -rf · Accepted Answer · 2013-03-16 21:08:34Z

7

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]

answered Mar 16, 2013 at 21:08

rm -rf♦

89.3k21 gold badges296 silver badges479 bronze badges

$\begingroup$ Equivalently: splitList[l_List] := With[{n = Length[l]}, Pick[l, IntegerDigits[Ceiling[2 (2^n - 1)/3], 2, n], #] & /@ {1, 0}] $\endgroup$
– J. M.'s missing motivation ♦
Commented May 6, 2013 at 6:24

Add a comment |

Leonid Shifrin · Accepted Answer · 2013-03-16 13:36:57Z

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, 2013 at 13:36

Leonid Shifrin

115k16 gold badges333 silver badges424 bronze badges

$\begingroup$ That looks too complicated. I would write: Reap[# ~Sow~ Mod[#2, 2] & ~MapIndexed~ lst][[2]] $\endgroup$
– Mr.Wizard
Commented Mar 16, 2013 at 13:54
$\begingroup$ @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. $\endgroup$
– Leonid Shifrin
Commented Mar 16, 2013 at 14:25

Add a comment |

DavidC · Accepted Answer · 2013-03-17 01:43:22Z

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 · Accepted Answer · 2013-03-17 12:23:14Z

5

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, 2013 at 12:23

answered Mar 16, 2013 at 14:18

Michael E2

245k18 gold badges351 silver badges774 bronze badges

$\begingroup$ g is in both your output lists! $\endgroup$
– DavidC
Commented Mar 17, 2013 at 4:26

Add a comment |

chyanog · Accepted Answer · 2013-03-16 14:50:45Z

2

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

edited Mar 16, 2013 at 14:50

answered Mar 16, 2013 at 14:09

chyanog

15.8k3 gold badges41 silver badges83 bronze badges

Add a comment |

eldo · Accepted Answer · 2024-07-23 22:02:57Z

1

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

Using EveryOther by Wolfram Staff

EveryOther = ResourceFunction["EveryOther"];

EveryOther[list]

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

Using GroupBy

Keys @ Values @ GroupBy[OddQ] @ Association @ MapIndexed[Rule] @ list

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

answered Jul 23 at 22:02

eldo

83.1k6 gold badges72 silver badges202 bronze badges

Add a comment |

Guglielmo Ferranti · Accepted Answer · 2021-11-05 16:31:49Z

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 5, 2021 at 16:31

Guglielmo Ferranti

1

Add a comment |

Stack Exchange Network

Pretty way to group elements at odd and even positions

12 Answers 12

Your Answer

Not the answer you're looking for? Browse other questions tagged
list-manipulation
or ask your own question.

Linked

Hot Network Questions

Pretty way to group elements at odd and even positions

12 Answers 12

Your Answer

Sign up or log in

Post as a guest

Not the answer you're looking for? Browse other questions tagged list-manipulation or ask your own question.

Linked

Related

Hot Network Questions

Not the answer you're looking for? Browse other questions tagged
list-manipulation
or ask your own question.