Separate a list into even-indexed and odd-indexed parts

Question

Inspired by this question:

Make a function (or a full program) that receives a list of numbers and outputs the list rearranged, so that even-indexed numbers appear first, and odd-indexed numbers follow. The values of the numbers themselves don't affect ordering - only their indices do. All indices are zero-based.

For example:

Input: [0, 1, 2, 3, 4]

Output: [0, 2, 4, 1, 3]

Another example:

Input: [110, 22, 3330, 4444, 55555, 6]

Output: [110, 3330, 55555, 22, 4444, 6]

Use most natural representation for lists that your language has. There are no limitations on complexity (e.g. allocating a temporary list is OK - no need to do it in-place).

P.S. It should work for the empty list (empty input => empty output).

Answer 1

JavaScript (Node.js), 47 bytes

x=>f=i=>1/x[i|i]?[x.splice(i,1)[0],...f(-~i)]:x

Try it online!

JavaScript (Node.js), 50 bytes

x=>(i=a=[]).concat(x.filter(v=>i++%2||!a.push(v)))

Try it online!

Not shortest now but fun

Answer 2

Elm, 78 bytes

g x y i z=case(z,i)of
 (a::b,_)->g(y++[a])x(1-i)b
 (_,0)->x++y
 _->y++x

g[][]1

Answer 3

Pyth, 8 bytes

+%2Q%2tQ

Relatively simple

Answer 4

Vitsy, 22 Bytes

Vitsy really wasn't made to do this...

r' 'Vl2/\[N{VO]l\[NVO]
r                       Reverse the implicit numerical input stack.
 ' 'V                   Save the "space" character as a global final variable.
     l2/\[....]         Repeat the stuff in the brackets the length of the input
                        stack divided by 2.
          N{VO          Output the top item of the stack as a number, then shift
                        the stack over once to the left, push a space, output it.
               l\[...]  For the rest of the stack, repeat that many times...
                  NVO   Output the top item of the stack as a number separated 
                        by a space.

Answer 5

Minkolang 0.12, 15 bytes

$nI2:[i1+g]r$N.

Try it here.

Explanation

$n                 Read in all of input as numbers
  I2:              The length of the stack divided by 2 (n)
     [             Open for loop that repeats n times
      i1+          Loop counter + 1
         g         Gets the (i+1)th item from the stack and puts it on top
          ]        Close for loop
           r       Reverse the stack (for outputting)
            $N.    Output the whole stack as numbers and stop.

Answer 6

Clojure/ClojureScript, 52 bytes

(defn f[l](flatten(map #(take-nth 2 %)[l(rest l)])))

Written in a ClojureScript REPL, should also be valid Clojure.

Answer 7

R, 49 bytes

q<-function(x)c(x[seq(x)%%2==1],x[seq(x)%%2==0])

Call it as q(blah). Or, if x already contains the list to be rearranged, then

c(x[seq(x)%%2==1],x[seq(x)%%2==0])

is just 35 bytes.

Answer 8

F#, 64

fun x->List.mapi(fun i l->l,i%2)x|>List.sortBy snd|>List.map fst

Inspired by Sehnsucht's answer (but not enough rep to comment).

Maps each value to a tuple where the second entry is the modulo of the list index, sorts by modulo, then maps back to the original value.

Answer 9

Prolog, 103 bytes

r([E,O|T],[E|A],[O|B]):-r(T,A,B).
r([],[],[]).
r([E],[E],[]).
p(L):-r(L,A,B),append(A,B,X),write(X).

Example

>p([1,2,3,4,5]).
[1,3,5,2,4]

Answer 10

Hassium, 191 Bytes

This one was pretty long :(
It reads the array from args, so run this with hassium file.has 0 1 2 3 4

func main(){a=args;e,o=[]for(c=0;c<a.length;c++)if(c%2==0)e.add(a[c])else o.add(a[c])print("["+(e+o).toString().replace("{", "").replace("}", "").replace("Array", "").replace("  ", "")+"]");}

Run and see expanded with test case here

Answer 11

Go, 92 bytes

func s(l []int) (r []int){for i:=0;i<len(l)*2;i+=2 {r=append(r,append(l,l...)[i])};return}

"Go. at least it's shorter than prolog"

degolf

func s(l []int) (r []int){
   for i:=0;i<len(l)*2;i+=2 {
      r=append(r,append(l,l...)[i])
   }
   return
}

Answer 12

𝔼𝕊𝕄𝕚𝕟, 12 chars / 22 bytes (noncompetitive)

Ѩťᶏש,Ѩą(ï,2⸩

Try it here (Firefox only).

Just switched to Lodash, which has way more functions. Thus, this answer is rendered noncompetitive.

Answer 13

bash and GNU coreutils, 68 bytes

We assume that the list is newline-separated and passed on standard input.

(paste - <(seq 0 5 9999)|tee x|grep 0$;grep 5$<x)|cut -f1|grep -v ^$

Unfortunately this will ignore any inputs beyond index 1999, so it doesn't quite meet the spec.

It also clobbers a hardcoded temporary file ('x'), which could be problematic if run in parallel, and it doesn't remove it afterwards. Sorry about that!

Answer 14

PHP, 78 69 bytes

PHP can chunk and slice, but not interleave arrays; that makes this a bit bulky:

function(&$a){while($i++<count($a)>>1)$a[]=array_splice($a,$i,1)[0];}

Call by reference or try it online.

---

first approach (programs for 78 bytes):

for(;++$i<$argc;)echo",",$argv[$i++];for($i=1;++$i<$argc;)echo",",$argv[$i++];

prints a leading comma; insert [!$i] before the first$argv to remove it.

Two other 78 byte solutions (print a leading and a trailing comma):

for($n=$argc-2|1;++$i<$argc*2;)$i&1?print",".$argv[$i]:$argv[$n+=2]=$argv[$i];
for($n=$argc-2;++$i<$argc*2;)$i&1?print",".$argv[$i]:$argv[1|$n+=2]=$argv[$i];

Run with php -nr '<code>' <arguments> or try them online

Answer 15

Factor, 34 bytes

[ dup <evens> swap <odds> append ]

Try it online!

It's a quotation (anonymous function) that takes a sequence from the data stack as input and leaves a sequence on the data stack as output. It rips out the even indices into a sequence, rips out the odd indices into a sequence, and smushes them back together. [ 2 group flip concat ] works for sequences of even length, but flip can only transpose square matrices correctly.

Answer 16

Rust 109 bytes

fn f(x:Vec<u8>)->Vec<u8>{x.iter().cloned().step_by(2).chain(x.iter().cloned().skip(1).step_by(2)).collect()}

"at least it's shorter than C#"

Answer 17

Go, 97 96 91 bytes, idiomatic

func(L[]int)(E,O[]int){for i,e:=range L{if i%2<1{E=append(E,e)}else{O=append(O,e)}}
return}

Attempt This Online!

Because Go supports multiple return values, this returns 2 lists, the even-indexed elements and the odd-indexed elements.

• -1 byte: ==0 into <1
• -5 bytes: return values share a type

Go, 96 bytes, generic

func f[T any](L[]T)(E,O[]T){for i,e:=range L{if i%2<1{E=append(E,e)}else{O=append(O,e)}}
return}

Attempt This Online!

Go, 122 114 bytes (literal interpretation)

func(L[]int)[]int{var E,O[]int
for i,e:=range L{if i%2<1{E=append(E,e)}else{O=append(O,e)}}
return append(E,O...)}

Attempt This Online!

This longer solution merges the filtered lists into a single list.

• -8 bytes: E and O share the same type

Answer 18

C# 7.3, 100 bytes

List<int> M(List<int> x)=>x.Select((y,i)=>(y,i)).GroupBy(y=>y.i%2,y=>y.y).SelectMany(y=>y).ToList();

This is pretty much idiomatic for C#, but I don't think a non-idiomatic solution would be much shorter.

Answer 19

Arturo, 27 bytes

$=>[i:0arrange&=>[i%2'i+1]]

Try it

Answer 20

Thunno, \$ 3 \log_{256}(96) \approx \$ 2.47 bytes

ZlS

Attempt This Online!

Explanation

ZlS  # Implicit input
Zl   # Uninterleave
  S  # Sum (acts as flatten 
     # for nested lists)
     # Implicit output

Answer 21

Java 8 (OpenJDK 8), 70 bytes

Pretty much straightforward in Java

l->{for(int i=1;i<=l.size()/2;l.remove(i++))l.add(l.get(i));return l;}

Sadly not golfable using only streams because index isn't easily accessible from inside, and conversion from stream to list is still a pain until Java 16

Try it online!

Answer 22

Zsh, 34 bytes

for i j;a+=($i) b+=($j);echo $b $a

Try it online!. Note that arrays in Zsh are 1-indexed, that's why the output appears backwards from the example given. If the requirement for "even" indices first is relaxed, and the order of outputs is more important, just switch $a and $b

Answer 23

Haskell + hgl, 8 bytes

mp<$%uak

Attempt This Online!

Explanation

• uak: splits a list into even and odd indices
• mp: "Monoidal action", concatenates two lists
• (<$%): Uncurry compose, this composes a curried two argument function like mp with a function that returns a tuple like uak.

Reflection

I'm pretty happy with this. Really glad to have (<$%) and uak is proving to be quite useful. It is worth considering if either or both of these deserve a "promotion" to a smaller byte count.

Answer 24

JavaScript (Node.js), 49 bytes

After a few fails it finally works, but is now longer than expected :-/

t=>t.map((_,i)=>t[(i*2-1)%((l=t.length)+~l%2)+1])

Try it online!

Answer 25

Thunno 2 S, 1 byte

z

Attempt This Online!

Explanation

    # Implicit input
z   # Uninterleave the input into two pieces
    #   e.g.  [1,2,3,4,5,6]  ->  [[1,3,5], [2,4,6]]
    #   e.g.  [0,1,2,3,4]    ->  [[0,2,4], [1,3]]
    # S flag takes the sum of this list
    #  i.e. flattens the nested list
    #   e.g.  [[1,3,5], [2,4,6]]  ->  [1,3,5,2,4,6]
    #   e.g.  [[0,2,4], [1,3]]    ->  [0,2,4,1,3]
    # Implicit output