[Question]
  [
Inspired by [this](https://stackoverflow.com/q/33787939/509868) 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]
## Python, 23 bytes
```
lambda x:x[::2]+x[1::2]
```
[Try it online](http://ideone.com/fork/CFl1vm)
[Answer]
# Pyth, 5
```
o~!ZQ
```
[Try it online](http://pyth.herokuapp.com/?code=o~%21ZQ&input=%5B1%2C2%2C3%2C4%2C5%5D&debug=0), or run a [Test Suite](http://pyth.herokuapp.com/?code=o~%21ZQ&input=%5B1%2C2%2C3%2C4%2C5%5D&test_suite=1&test_suite_input=%5B%5D%0A%5B1%5D%0A%5B0%2C1%2C2%2C3%5D%0A%5B0%2C1%2C2%2C3%2C4%5D%0A%5B110%2C%2022%2C%203330%2C%204444%2C%2055555%2C%206%5D&debug=0)
### Explanation
```
o~!ZQ    ## implicit: Z = 0; Q = eval(input)
o   Q    ## sort Q using a supplied function
 ~!Z     ## Use the old value of Z, then set Z to be not Z
         ## This assigns a weight to each number in the list, for example given [0,1,2,3,4]
         ## This will give (value, weight) = [(0,0), (1,1), (2,0), (3,1), (4,0)]
         ## The values are sorted by weight and then by index
         ## This happens because Pyth is written in Python, which performs stable sorts
```
[Answer]
## CJam, 7 bytes
```
{2/ze_}
```
Pushes a block (the closest thing to an unnamed function) which transforms the top stack element as required.
[Test it here.](http://cjam.aditsu.net/#code=%7B2%2Fze_%7D%3AF%3B%0A%0A%5B110%2022%203330%204444%2055555%206%5D%0AFp)
### Explanation
The explanation assumes that the top of the stack is the array `[0 1 2 3 4]`. The actual values don't affect the computation.
```
2/  e# Split the array into chunks of two: [[0 1] [2 3] [4]]
z   e# Zip/transpose, which works on ragged arrays: [[0 2 4] [1 3]]
e_  e# Flatten the result: [0 2 4 1 3]
```
[Answer]
## [Labyrinth](https://github.com/mbuettner/labyrinth), ~~28~~ ~~25~~ ~~24~~ ~~23~~ 22 bytes
```
" >
?!?:|}\{@
@\?"":)!
```
This was mad fun! :) That is by far the most densely compressed Labyrinth program I've written so far. I had so many versions at 20 and 21 bytes which *almost* worked that I'm still doubting this is optimal...
This takes input as a list of *positive* integers (with an arbitrary delimiter), and prints the result to STDOUT as linefeed-delimited integers.
**The hunt for 20/21 bytes:** I've checked all programs of the form
```
" XX
?!?X}\{@
@\?XX)!
```
where `X` is any reasonable character by brute force, but didn't find any valid solutions. Of course that doesn't mean that a shorter solution doesn't exist, but it's not possible to force 20-byte programs without a decent amount of assumptions on its structure.
### Explanation
*(The explanation is slightly outdated, but I'm still not convinced the solution is optimal, so I'll wait with updating this.)*
So, normally Labyrinth programs are supposed to look like mazes. While the instruction pointer is in a corridor, it will follow that corridor. When the IP hits any kind of junction, the direction is determined based on the top value of Labyrinth's main stack (Labyrinth has two stacks, with an infinite amount of zeroes at the bottom). That normally means that any non-trivial loop will be quite expensive, because if you have non-wall cells all over the place *everything* is a junction, and in most cases the top of the stack won't have the right value for the IP to take the path you would like it to take. So what you do is you enlarge the loops such that they have a whole in the centre with only one well-defined entry and exit point each.
But this time I was really lucky and everything fit so well together, that I could squash it all into one big clump. :)
Control flow starts at the `_` going South. The `_` pushes a zero onto the main stack. That may seem like a no-op, but this increases the (non-implicit) stack depth to `1` which we'll need later.
`?` reads an integer from STDIN. If there are no more integers to be read, this pushes zero. In that case, the IP keeps moving South and `@` terminates the program right away (because the input list is empty). Otherwise, the IP turns East.
We're now entering a very tight loop with two exit points:
```
 !?;
 \?
  ;
```
`!` prints the integer back to STDOUT, leaving only a zero on the stack. The IP keeps moving East, and `?` reads the next integer. If that is non-zero, we take a right and move South. `?` reads another one (the next even index). Again, if that is non-zero, we take a right and move West.
Then `\` prints a linefeed without changing the stack, so we take another right, moving North. `!` prints that next even-index integer. Since now there is at least one (positive) odd-index integer on the stack, we keep turning right and the loop repeats.
Once either of those `?` hits the end of the list, they push a zero and move straight onto the corresponding `;`, which discards that zero.
In the case that there was only a single element in the list, we're done (because we've printed that right away), so the IP would keep moving East all the way to the `@`, again terminating the program (printing a trailing linefeed on the way).
Otherwise, we need to print the odd-index integers as well. In that case the two paths (from the two exit points of the first loop) merge on the middle `"`, turning East in either case.
`_` pushes a zero to avoid taking a left into the `@`, and `;` discards that zero. Now we enter a new loop:
```
     "}
     ""
```
The IP enters this on the bottom-left cell, moving North, going around the loop in a clockwise sense. The `}` shifts the top of the main stack over to the auxiliary stack. While there is still an element on the stack, the IP keeps doing its thing. Once everything has been shifted to the auxiliary stack (and reversed in the process), the IP keeps moving East instead, entering the last loop:
```
       \{@
       #!
```
`\` prints a linefeed again, `{` moves an item from the auxiliary stack back to main. If that was still an item of the list, it will be positive, and the IP turns South, where the item is printed with `!`. Then `#` pushes the stack depth (and now this is where the initial `_` is important, because this `#` ensures a positive stack depth), so that the IP still turns right, through the `\` and `{` again. 
After we've printed everything, `{` pulls a zero from the bottom of the auxiliary stack, the IP continues East, and `@` terminates the program.
[Answer]
# MATLAB, 24
```
@(x)x([1:2:end 2:2:end])
```
similar to the python one.
Thanks @LuisMendo for saving 2 bytes!
[Answer]
# [Haskell](https://www.haskell.org/), 37 bytes
```
concat.foldr(\x[l,r]->[x:r,l])[[],[]]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P802OT8vObFELy0/J6VII6YiOkenKFbXLrrCqkgnJ1YzOjpWJzo29n9uYmaegq1CQVFmXomCikKaQrShnp5l7H8A "Haskell – Try It Online")
The `foldr` recursively builds up the even list and odd list. Prepending an element to the list is updated by prepending it to the odd list and calling it the new even list, and calling the previous even list the new odd list. Then, the pair `[l,r]` is concaternated to `l++r`. 
Thanks to Ørjan Johansen for saving 5 bytes using two-element lists in place of tuples.
---
**42 bytes:**
```
f l=[x|p<-[even,odd],(i,x)<-zip[0..]l,p i]
```
Adds indices to the list `l` and filters either the even or the odd ones.
---
```
g(a:_:l)=a:(g l)
g l=l
f l=g l++(g$drop 1 l)
```
Yet another format, for 44. The function `g` takes every even-indexed element. The odd indices are gotten by first dropping an element, then applying `g`. If `l` was guaranteed non-empty, we could safely just do `tail` for 41
```
g(a:_:l)=a:(g l)
g l=l
f l=g l++g(tail l)
```
[Answer]
## J, 8 bytes
```
/:0 1$~#
```
This is a monadic (one-argument) verb, used as follows:
```
  (/:0 1$~#) 110 22 3330 4444 55555 6
110 3330 55555 22 4444 6
```
## Explanation
```
/:        Sort the input array according to
  0 1     the array 0 1
     $~   repeated enough times to be of length
       #  length of input
```
[Answer]
## PowerShell v3+, ~~75~~ ~~67~~ ~~49~~ 47 bytes
```
$l=,@()*2
$args|%{$l[($f=!$f)]+=$_}
$l[0]
$l[1]
```
[Try it online!](https://tio.run/##bZDRaoQwEEXf8xWz2bEk3SkYtT4UBP9jkUW60RZCa9XSgvrt7kS3Fpa9D8PMvWcGkubzx7bdm3VuxgoyGGZ0GeVKP0YCy7buxmBAd1RYZTusdHHI8DQJdsLCV1PMkxC5EsAilauQwBBEBLEmCJfO@OEOQJBsTHKLGeMDj8UxdwmL4NmLIOW1JV@zq@vhFUv/zzDJRQsNIwQwLD6WhPa3sa@9PfOL8bS6re2@Xc/GA39EXsIeusaVff/@US@ARCWvkHyyX3K7IfXL37YU03wB "PowerShell – Try It Online")
Expects input via splatting, as shown on the TIO link.
Creates an matrix `$l` as an array of arrays, then pipes the input `$args` into a loop `|%{}`. Each time through the loop, we add an element to one of the two child arrays of `$l` by flip-flopping the `$f` variable using Boolean logic. The first time through, `$f` is `$null`, the `!` of which is `$true`, or `1` when indexing into an array. This means the first element gets put into the second array of `$l`, so that's why `$l[1]` gets output first.
*Props to [TessellatingHeckler](https://codegolf.stackexchange.com/users/571/tessellatingheckler) for the golfing assistance and this variation.*  
*-2 bytes thanks to mazzy.*
---
### Caveats
Going strictly as the question is written, this is technically invalid, as PowerShell doesn't have a concept of "lists" as pseudo-immutable objects, only arrays or hash tables (aka dictionaries). So, I'm treating the question's line "*Use most natural representation for lists that your language has*" as asking about arrays, as that's the closest PowerShell has. Additionally, output is one element per line, since that's the default PowerShell way to write out an array. This means an input of `(0,1,2,3,4)` will output `0\r\n2\r\n4\r\n1\r\n3\r\n`.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~4~~ 3 bytes
```
ŒœF
```
[Try it online!](https://tio.run/##y0rNyan8///opKOT3f4fbn/UtObopIc7ZwDpyP//ow0NDXQUjIx0FIyNjYEsEyDQUTAFAR0Fs1gdhWigoCFQBVABUBYkEAsA "Jelly – Try It Online")
## How it works
```
ŒœF - Main link. Argument: L (a list) e.g.
Œœ  - Odd-even; Group elements at even and odd indices
  F - Flatten
```
[Answer]
# F#, ~~79~~ ~~77~~ 56
```
fun x->List.foldBack(fun x (l,r)->x::r,l)x ([],[])||>(@)
```
Based on one of the Haskell answer
```
fun x->x|>List.indexed|>List.partition(fst>>(&&&)1>>(=)0)||>(@)|>List.map snd
```
We first index the list, then partition it with criteria : first item (the index) anded with 1 equal 0.  
That gives us a pair of list of pairs ; first list will contains all indexed evens and the other the indexed odds.  
From that we reassemble the two list with append operator and finally discard the index.
*Edit : missed an obvious one there is no need to name the arg "xs" (habits) so can reduce to a 1-letter name*
---
I also have a potential 76 bytes one which is basically the same one but defined as function composition. Problem is it doesn't compile **as a value** but will effectively work with any list argument given so unsure if it's ok or not :
```
List.indexed>>List.partition(fst>>(&&&)1>>(=)0)>>fun(e,o)->e@o|>List.map snd
```
---
*Note: List.indexed is only available from F#4.0 despite not being documented in MSDN yet*
[Answer]
# JavaScript (ES6), 52 bytes
It also does it in one pass
```
x=>x.map((v,i)=>x[(i*=2)>=(z=x.length)?i-z+--z%2:i])
```
```
F=x=>x.map((v,i)=>x[(i*=2)>=(z=x.length)?i-z+--z%2:i])
input.oninput = setValue;
function setValue() {
  var arr = input.value.match(/\d+/g) || [];
  unsorted.innerHTML = arr.join(', ');
  sorted.innerHTML = F(arr).join(', ');
}
setValue();
```
```
* {
  font-family: monospace
}
th {
  text-align: right;
  padding-right: 0.5em;
}
```
```
<input id="input" type="text" value="0 1 2 3 4 5 6"/>
<hr/>
<table>
  <tr>
    <th>Unsorted:</th>
    <td id="unsorted"></td>
  </tr>
  <tr>
    <th>Sorted:</th>
    <td id="sorted"></td>
  </tr>
</table>
```
[Answer]
# [convey](http://xn--wxa.land/convey/), 16 bytes
```
{
"\`0
|@&;`}
2}
```
[Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoie1xuXCJcXGAwXG58QCY7YH1cbjJ9IiwidiI6MSwiaSI6IjAgMSAyIDMgNCJ9)
[![test run](https://i.stack.imgur.com/Ld8fv.gif)](https://i.stack.imgur.com/Ld8fv.gif)
Get the input `{` at the top, copy `"` down and left. The list mod `|` 2 chooses `@` if the elements go down straight into the output `}` or right into the queue `&`. After the last element has passed through `\`, the length `n` of the list gets pushed to `:`, where `n` elements from the queue then gets passed through.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 1 byte
```
ó
```
[Try it online!](https://tio.run/##y0osKPn///Dm//@jDXQUDHUUjHQUjHUUTGIB "Japt – Try It Online")
[Answer]
# Julia, 23 bytes
```
i->i[[1:2:end;2:2:end]]
```
[Answer]
## [Perl 6](http://perl6.org), 25 bytes
This is the shortest lambda I could come up with.
```
{|.[0,2...*],|.[1,3...*]} # 25 byte "Texas" version
{|.[0,2…*],|.[1,3…*]}     # 25 byte "French" version
```
```
say {|.[0,2…*],|.[1,3…*]}( ^5 ); # (0 2 4 1 3)␤
say ((0..4),('m'..'q'),(5..9)).map: {|.[0,2…*],|.[1,3…*]}
# ((0 2 4 1 3) (m o q n p) (5 7 9 6 8))␤
# bind it as a lexical sub
my &foo = {|.[0,2…*],|.[1,3…*]}
say foo [110, 22, 3330, 4444, 55555, 6]; # (110 3330 55555 22 4444 6)␤
say [~] foo 'a'..'z' # acegikmoqsuwybdfhjlnprtvxz␤
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 3 bytes
```
ñÏu
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=8c91&input=WzExMCwgMjIsIDMzMzAsIDQ0NDQsIDU1NTU1LCA2XQotUQ==)
```
ñÏu     :Implicit input of array
ñ       :Sort by
 Ï      :Passing the 0-based index of each through a function
  u     :  Modulo 2 of index
```
---
```
ó c
```
[Try it](https://ethproductions.github.io/japt/?v=1.4.6&code=8yBj&input=WzExMCwgMjIsIDMzMzAsIDQ0NDQsIDU1NTU1LCA2XQotUQ==)
```
ó c     :Implicit input of array
ó       :Split into 2 arrays of every 2nd item
  c     :Flatten
        :Implicit output
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 4 bytes
```
ΣTC2
```
[Try it online!](https://tio.run/##yygtzv6f@6ip8f@5xSHORv///4@ONtAx1DHSMdYxidWJNjQ00DECcoyNDXRMgEDHFAR0zGJjAQ "Husk – Try It Online")
```
  C2    # split list into 2-element sublists
 T      # transpose
Σ       # flatten list of lists
```
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 30 bytes
```
s/\S+\K( \S+)( ?)/$\.=$1;$2/ge
```
[Try it online!](https://tio.run/##K0gtyjH9/79YPyZYO8ZbQwFIaWoo2Gvqq8To2aoYWqsY6aen/v9voGCoYKRgrGCiYKpgpmCuYKFgqWBo8C@/oCQzP6/4v66vqZ6BocF/3QIA "Perl 5 – Try It Online")
Input and output are space separated.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
ι˜
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3M7Tc/7/jzY0NNBRMDLSUTA2NgayTIBAR8EUBHQUzGIB "05AB1E – Try It Online")
## How it works
```
ι˜ - Program. Push the input L to the start
ι  - Uninterleave L
 ˜ - Flatten
```
[Answer]
# [K (ngn/k)](https://codeberg.org/ngn/k), 21 bytes
```
{t,x^t:x@&(0=2!)'!#x}
```
[Try it online!](https://ngn.codeberg.page/k#eJxLs6ou0amIK7GqcFDTMLA1UtRUV1SuqOXiSos2UDBUMFIwVjCJBXIMDQ0UjIA8Y2MDBRMgUDAFAQWzWAAXng7R)
*Down 2 bytes thanks to ngn*
# [K (ngn/k)](https://codeberg.org/ngn/k), 23 bytes
```
{t:x@&(0=2!)'!#x;t,x^t}
```
[Try it online!](https://ngn.codeberg.page/k#eJxLs6ousapwUNMwsDVS1FRXVK6wLtGpiCup5eJKizZQMFQwUjBWMIkFcgwNDRSMgDxjYwMFEyBQMAUBBbNYADmdD4A=)
The old solution is kept because of the explanations.
Explanations:
```
{t:x@&(0=2!)'!#x;t,x^t}  Main function. Takes x as input
             !           Create a range from 0 to
              #x         Length of x - 1
            '            For each number in the range (i)
      (    )             Check if
         2!              i mod 2
       0=                is equal to 0
     &                   Where (get indices of truthy values)
   x@                    x at each indices
 t:             ;        Assigned to variable t
                 t,      t concat with
                   x^t   x without the elements in t
```
[Answer]
# [Fig](https://github.com/Seggan/Fig), \$2\log\_{256}(96)\approx\$ 1.646 bytes
```
fy
```
[Try it online!](https://fig.fly.dev/#WyJmeSIsIlsxMTAsIDIyLCAzMzMwLCA0NDQ0LCA1NTU1NSwgNl0iXQ==)
```
fy
 y # Uninterleave
f  # Flatten
```
[Answer]
## Mathematica, 40 bytes
```
#[[;;;;2]]~Join~If[#=={},#,#[[2;;;;2]]]&
```
`{}[[2;;;;2]]` will throw an error.
[Answer]
## Burlesque, 12 Bytes
```
J2ENj[-2EN_+
```
Usage as in:
```
blsq ) {0 1 2 3 4}J2ENj[-2EN_+
{0 2 4 1 3}
blsq ) {110 22 3330 4444 55555 6}J2ENj[-2EN_+
{110 3330 55555 22 4444 6}
```
**Explanation:**
```
J     -- duplicate
2EN   -- every 2nd element
j     -- swap
[-    -- tail
2EN   -- every 2nd element
_+    -- concatenate parts
```
Although once the new update is released you can do this with the new
*Unmerge* built-in (which does the opposite of the merge `**` built-in):
```
blsq ) {110 22 3330 4444 55555 6}J2ENj[-2EN**
{110 22 3330 4444 55555 6}
```
[Answer]
# K, 10 bytes
```
{x@<2!!#x}
```
Based on the 5-byte Pyth answer.
[Answer]
# Perl, ~~35~~ 33 bytes
```
perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
```
31 bytes + 2 bytes for `-ap`. Reads a space-delimited string from STDIN:
```
$ echo 0 1 2 3 4 | perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
0 2 4 1 3
$ echo 110 22 3330 4444 55555 6 | perl -ape 'push@{$|--},$_ for@F;$_="@0 @1"'
110 3330 55555 22 4444 6
```
When the input is empty, prints a single space, which I would consider equivalent to an empty list. If not, can be fixed at a cost of 4 bytes with:
```
perl -anE 'push@{$|--},$_ for@F;$,=$";say@0,@1'
```
(requires Perl 5.10+, prints a trailing newline)
or at a cost of 5 bytes with:
```
perl -ape 'push@{$|--},$_ for@F;$_=join$",@0,@1'
```
(no trailing whitespace)
## How it works
This solution uses the `-a` flag, which splits the input on whitespace and puts the results in the `@F` array.
The real magic happens in the `push`:
```
push@{$|--},$_
```
The [`$|` variable](http://perldoc.perl.org/perlvar.html#%24%7C) is normally used to force output flushing, but it has another interesting property: when decremented repeatedly, its value toggles between 0 and 1.
```
perl -E 'say $|-- for 0..4'
0
1
0
1
0
```
Taking advantage of the fact that [there are no restrictions on identifiers specified via symbolic dereferencing](https://stackoverflow.com/a/4800711/176646), we alternately push array elements onto the `@0` and `@1` arrays, so `@0` ends up with all the even-indexed elements and `@1` with the odds. Then we simply concatenate the stringified arrays to get our output.
[Answer]
## C, 70
Nothing special, just a index mapping function.
```
a=0;main(int c,int** v){for(c--;a<c;)puts(v[1+a*2%c+!(a++<c/2|c%2)]);}
```
**Less golfed**
```
a=0;
main(int c, int** v) {
  for(c--; a<c;)
    puts(v[1 + a*2%c + !(a++ < c/2 | c%2) ]);
}
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 11 bytes
```
{⍵[⍒2|⍳≢⍵]}
```
Alternatively:
```
{⍵[⍒≠\=⍨⍵]}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24TqR71box/1TjKqedS7@VHnIiA3thYopWBoaKBgZKRgbGxsoGACBAqmIKBgBgA "APL (Dyalog Unicode) – Try It Online")
Explanation:
```
{⍵[⍒2|⍳≢⍵]}
      ⍳≢⍵       ⍝ indices from 1 to the length of the input vector.
    2|          ⍝ their divisibility by two; essentially generate 1 0 1 0...
   ⍒            ⍝ grade down: put odd indices first before even indexed indices.
 ⍵[      ]      ⍝ pick from the input
```
[Answer]
# JavaScript, 49 bytes
```
n=>[...(x=f=>n.filter((a,b)=>b%2==f))(0),...x(1)]
```
Explanation: Creates a list composed of the results of spreading arrays filtered by the index of each element modulo 2.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~53~~ ~~36~~ 30 bytes
```
->a{i=0
a.sort_by{[i%2,i+=1]}}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsEiN9ulpSVpuhb7dO0SqzNtDbgS9Yrzi0rikyqrozNVjXQytW0NY2trIYpuhhcouEVHG-gY6hjpGOuY6JjqmOmYx8YqKCvY2ikAxY2AYmZAWWOgjHksF6Zq7GpjIcYvWAChAQ)
## Ruby, 24 bytes
This appears to work but could fail *in theory* because "the ordering of equal elements is indeterminate and [may be unstable](https://ruby-doc.org/core-3.1.2/Enumerable.html#method-i-sort_by)." Sorting by `[i%2,i+=1]` above [solves this instability](https://8thlight.com/blog/will-warner/2013/03/26/stable-sorting-in-ruby.html).
```
->a{i=1
a.sort_by{i^=1}}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72kqDSpcsEiN9ulpSVpuhY7dO0SqzNtDbkS9Yrzi0rikyqrM-NsDWtrIdI3wwsU3KKjDXQMdYx0jHVMdEx1zHTMY2MVlBVs7RSA4kZAMTOgrDFQxjyWC1M1drWxEOMXLIDQAA)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 3 bytes
```
y"f
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyJBIiwiIiwieVwiZiIsIiIsIlswLCAxLCAyLCAzLCA0XVxuWzExMCwgMjIsIDMzMzAsIDQ0NDQsIDU1NTU1LCA2XSJd)
Uninterleave, pair the results and flatten
]