[Question]
  [
Given a string, reverse it interleavingly. Here's how to do it for `abcdefghi` and `abcdefghij`, 0-indexed:
1. Separate the chars at even indices from the chars at odd indices:
```
a c e g i
 b d f h  
a c e g i
 b d f h j
```
2. Reverse the chars at odd indices:
```
a c e g i
 h f d b  
a c e g i
 j h f d b
```
3. Interleave into one string again:
```
ahcfedgbi  
ajchefgdib
```
# Rules
* You must support both even-length and odd-length strings.
* 0-index-wise, you must reverse the chars at odd indices, not even.
* 1-index-wise, of course, you must reverse the chars at even indices, not odd.
* Input will consist of printable ASCII (code points 32-126), no newlines.
* You can take input either as a string or as a list of chars (NOT 1-char strings). E.g. `String`/`char[]` or `char*` are allowed, but `String[]`/`char[][]` or `char**` aren't.
# Test cases
```
Input
Output
```
 
```
Hello, World!
HdlroW ,olle!
Hello World!
H!llooW rlde
ABCDEFGHIJKLMNOPQRSTUVWXYZ
AZCXEVGTIRKPMNOLQJSHUFWDYB
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
 }"{$y&w(u*s,q.o0m2k4i6g8e:c<a>_@]B[DYFWHUJSLQNOPMRKTIVGXEZC\A^?`=b;d9f7h5j3l1n/p-r+t)v'x%z#|!~
P
P
AB
AB
xyz
xyz
```
For the empty string, return the empty string itself.
  
[Answer]
# [MATL](https://github.com/lmendo/MATL), 8 bytes
```
t2L)P5M(
```
[Try it online!](https://tio.run/nexus/matl#@19i5KMZYOqr8f@/emJSckpqWnpGpjoA "MATL – TIO Nexus") Or [verify all test cases](https://tio.run/nexus/matl#S/hfYuSjGWDqq/HfJeS/ukdqTk6@jkJ4flFOiqI6F4SP4Do6Obu4url7eHp5@/j6@QcEBgWHhIaFR0RGASUVFJWUVVTV1NU1NLW0dXT19A0MjYxNTM3MLSytrG1s7ewdcGuPjomNi09ITEpOSU1Lz8jMys7JzcsvKCwqLiktK6@orKquqa0DWhEAdgOQAAqpAwA).
### Explanation
```
t     % Implicit input. Duplicate
      % STACK: 'abcdefghi', 'abcdefghi'
2L    % Push [2, 2, 1j]. This represents 2:2:end when used as an index
      % STACK: 'abcdefghi', 'abcdefghi', [2, 2, 1j]
)     % Get entries at those indices
      % STACK: 'abcdefghi', 'bdfh'
P     % Flip
      % STACK: 'abcdefghi', 'hfdb'
5M    % Push [2, 2, 1j] again
      % STACK: 'abcdefghi', 'hfdb', [2, 2, 1j]
(     % Write entries at those indices. Implicit display
      % STACK: 'ahcfedgbi'
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 7 bytes
```
s2ZU2¦Z
```
This is a full program.
[Try it online!](https://tio.run/nexus/jelly#@19sFBVqdGhZ1P@Hu7ccbn/UtCby///EpOSU1LT0jEwuOCuLyyM1JydfRyE8vygnRRHCg3EcnZxdXN3cPTy9vH18/fwDAoOCQ0LDwiMio7i4ArgcA7gqKqsA "Jelly – TIO Nexus")
### How it works
```
s2ZU2¦Z  Main link. Argument: s (string)
s2       Split s into pairs.
  Z      Zip/tranpose, grouping characters by the parity of their indices.
     ¦   Sparse application:
   U         Upend; reverse both strings in the pair.
    2        Replace the second string with the reversed string.
      Z  Zip/transpose, interleaving the two strings.
```
[Answer]
# [Alice](https://github.com/m-ender/alice), 10 bytes
```
/ZY
\IOR@/
```
[Try it online!](https://tio.run/nexus/alice#@68fFckV4@kf5KD//79Hak5Ovo5CeH5RTooiAA "Alice – TIO Nexus")
Half of the bytes of this program are spent on correctly formatting the source, the actual commands are just `IYRZO`, because Alice has just the right builtins for this task.
### Explanation
As I said, the mirrors (`/\`), the newline and `@` are there just to make the ip move in the right direction and terminate the program at the end. The actual code, linearised, is the following:
```
IYRZO
I      Input a line
 Y     Unzip it into its even positions and its odd ones
  R    Reverse the odd positions
   Z   Zip it back again
    O  Output
```
Quite straightforward, I'd say.
[Answer]
# [Java (OpenJDK 8)](http://openjdk.java.net/), ~~108~~ ~~96~~ ~~94~~ 93 bytes
*Saved 1 byte by using [@Neil's neat trick](https://codegolf.stackexchange.com/a/123083/41805) of using `s[s.length+~i|1]`*
```
String f(char[]s){int a=s.length,b=0;String c="";for(;b<a;b++)c+=s[b%2<1?b:a+~b|1];return c;}
```
[Try it online!](https://tio.run/##dZFZV4JQFIWf8VdcKQsCSW0WycwGmwcrK6S6l0FRvNDloiniXydMXT71dvY6w/72Oh3Yh1nXM3HH6Ma6A30fVMIU41NIbT2uU2LjFrA4vQ2Jqvl8aGMKoOJLjolbtC0iJSfPh3SFZWXLJZyMSlBGgsDrguKrKFMo5cuoCIUJGuc1mZg0IBjochQzXoAcWwczM9B3bQP0oI252UVVG/EJCjO9OfeARWwOwKIdshDphmm12jYrLutOImqm47giaLjEMdILvZSV4@rJ6dl57eLy6vrm9u7@4bH@9PzSeH17T5og3WRXVjNr6xy/IYhZaTOXL2xt7@zu7R8U5ZJyWD76f11tNrWPz68lS9fpYdf7Jj4N@oOf4SgcR5PEY8r7xzwDn@OzEZ/kZepDn5o9yQ2o5CVJqYM5i4MSdavJFyqEwCHH87ycYqJUFP8C "Java (OpenJDK 8) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~52~~ 50 bytes
-2 bytes (and a bug fix) thanks to pxeger
```
s=bytearray(input())
s[1::2]=s[1::2][::-1]
print s
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v9g2qbIkNbGoKLFSIzOvoLREQ1OTqzja0MrKKNYWSkdbWekaxnIVFGXmlSgU//@v7pGak5OvoxCeX5SToqgOAA) or [Try all test cases](https://tio.run/##dY9ZV4MwEIXf@RWpVQNKVXCP4r7Uva5VgWoooaTGgCFYcPvrmFM9xydfZua7c@65M2kp44TbVR33uzGJeiENQBWSCEQ6NpAGMicoJcFC4FIJil0LIdt3fruLUMPyNSCIzAUHWTWIKSPAUs7CoTzNpa5MqaBcgsKEHodmpBfGcKpgkzCWmKCdCBbWoPbDf7i5tb2zu7ffPDg8Oj45PWudX1xeXd@0b@/u1RLURuqjY@Me1I2JSbMxNT1j2bNz8wuLS8toZdVZW9/43@56fufhEQdd9Wgvpv0n9syT9EVkMn8dFOXb@8fnl4poDW9QRUnwGw)
[Answer]
# Octave, 32 bytes
```
@(a,b=a(x)=a(flip(x=2:2:end)))a;
```
[Try it online!](https://tio.run/nexus/octave#@@@gkaiTZJuoUaEJJNJyMgs0KmyNrIysUvNSNDU1E63/J@YVa6h7pObk5CuE5xflpCiqa/4HAA "Octave – TIO Nexus")
[Answer]
## JavaScript (ES6), 48 bytes
```
f=
s=>s.replace(/./g,(c,i)=>i%2?s[s.length+~i|1]:c)
```
```
<input oninput=o.textContent=f(this.value)><pre id=o>
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 9 bytes
```
Ḋm2U
m2żÇ
```
[Try it online!](https://tio.run/nexus/jelly#@/9wR1euUShXrtHRPYfb////n5iUnJKalp6RmQUA "Jelly – TIO Nexus")
```
Ḋm2U Helper Link -> Dequeue (return last len-1 elements), take every second element, reverse
m2żÇ Main Link -> Take every second element, then interleave with the result of the helper link
```
*-1 byte thanks to Dennis*
[Answer]
# [Retina](https://github.com/m-ender/retina), ~~17~~ 13 bytes
```
O^$`(?<=\G.).
```
[Try it online!](https://tio.run/nexus/retina#U9VwT/jvH6eSoGFvYxvjrqep9/9/YlJySmpaekYmF5yVxeXo5Ozi6ubu4enl7ePr5x8QGBQcEhoWHhEZxaWgqKSsoqqmrqGppa2jq6dvYGhkbGJqZm5haWVtY2tn74Bbb3RMbFx8AsKa7JzcvPyCwqLiktKy8orKquqa2jqQK4AmAgA "Retina – TIO Nexus")
Fixed an error thanks to Neil.
Saved 4 bytes thanks to Kobi.
Selects each letter preceded by an odd number of characters and reverses them. Does this by using `\G` which matches the end of the last match.
[Answer]
# PHP>=7.1, 58 Bytes
```
for(;$i<$l=strlen($a=$argn);$i++)echo$a[$i&1?-$i-$l%2:$i];
```
[Online Version](http://sandbox.onlinephpfunctions.com/code/079962836fdfa0b85b9c82a8e096e8c4fafc41b3)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 14 13 bytes
12 bytes of code, +1 for the `-P` flag.
*Saved 1 byte thanks to @Shaggy*
```
¬ë íU¬Åë w)c
```
## Explanation:
```
¬ë íU¬Åë w)c
¬                   Split the input into an array of chars
 ë                  Get every other char, starting at index 0
   í                Pair with:
    U¬                Input, split into a char array
      Å               .slice(1)
       ë              Get every other char
         w            Reverse
           c       Flatten
-P                 Join into a string
```
[Try it online!](https://tio.run/##y0osKPn//9Caw6sVDq8NBdKtQFa5ZvL//0oeqTk5@ToK4flFOSmKSgq6AQA)
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 9 bytes
Requires `⎕IO←0` (default on many systems) for proper definition of odd and even.
```
⌽@{2|⍳≢⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qG@qp/@jtgkG/9OA5KOevQ7VRjWPejc/6lz0qHdr7f//aQrqiUnJKalp6RmZ6lzIvCx1AA "APL (Dyalog Unicode) – Try It Online")
`⌽` reverse
`@` at the elements filtered by the mask result from applying the
`{` anonyomous function
 `2|` the mod-2 of
 `⍳` the indices of
 `≢` the tally (length) of
 `⍵` the argument
`}` on the argument
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 7 bytes
`ι` and `.ι` have been added since this challenge was posted, both of them save bytes here.
```
Sι`R.ιJ
```
[Try it online!](https://tio.run/##yy9OTMpM/f8/@NzOhCC9czu9/v/3SM3JyddRCM8vyklRBAA "05AB1E – Try It Online")
If we were allowed to take a list of string of length 1, [`ι`R.ι`](https://tio.run/##yy9OTMpM/f//3M6EIL1zO///j1byUNJRUEoFETlwIh9E6IAIBRARDhcrgitJARGKSrEA) would work for 5 bytes.
```
S         # split the string into a list of characters
 ι        # uninterleave: push [even indices, odd indices]
  `       # push both values seperately to the stack
   R      # reverse the odd indices
    .ι    # interleave the two lists
      J   # join into a string
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), `s`, 3 bytes
```
yṘY
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=s&code=y%E1%B9%98Y&inputs=Hello%20World!&header=&footer=)
Turns out by making my answer valid I saved a byte. Oh the irony
## Explained
```
yṘY
y      # un-interleave
 Ṙ     # reverse
  Y    # re-interleave
```
[Answer]
# [Röda](https://github.com/fergusq/roda), 34 bytes
```
f a{a/=""a[::2]<>reverse(a[1::2])}
```
[Try it online!](https://tio.run/##K8pPSfz/P00hsTpR31ZJKTHaysoo1sauKLUstag4VSMx2hAkoFn7PzcxM6@aK9E2WikxKTklNS09I1NJB8HOAnI8UnNy8nUUwvOLclIUYXwE19HJ2cXVzd3D08vbx9fPPyAwKDgkNCw8IjIKKKmgGKOkrKKqpq6hqaWto6unb2BoZGxiamZuYWllbWNrZ@@AW3t0TExsXHwCwi3ZObl5@QWFRcUlpWXlFZVV1TW1dUA7QO4FuxnicKjzlWK5qtMUSqyjE7gSYmvT8osUShQy8xQSuWr/AwA "Röda – Try It Online")
### Explanation
```
a/=""                    Convert the argument a into an array of length-1 strings
      <>                 Interleave
a[::2]                   Every even element of a with
        reverse(a[1::2]) Every odd element of a reversed
```
---
Here is an alternative solution at the same bytecount
### ~~36~~ 34 bytes
```
{[_/""]|_[::2]<>reverse(_1[1::2])}
```
This is an anonymous function that takes input as a string from the input stream.
[Answer]
# [Python 2](https://docs.python.org/2/), 67 bytes
```
lambda s,j=''.join:j(map(j,zip(s[::2]+' ',s[1::2][::-1]+' ')))[:-1]
```
[Try it online!](https://tio.run/nexus/python2#S7ON@Z@TmJuUkqhQrJNlq66ul5WfmWeVpZGbWKCRpVOVWaBRHG1lZRSrra6grlMcbQhiAwV0DcEimpqa0SD2/4KizLwShTQN9cSk5JTUtPSMzCx1TS5MUaDgfwA "Python 2 – TIO Nexus")
[Answer]
# [OCaml](http://www.ocaml.org/), 70 bytes
```
let f s=String.(mapi(fun i c->s.[(length s land-2-i-i)*(i mod 2)+i])s)
```
[Try it online!](https://tio.run/##XYy7DoJAFERr@YoL1a4CBa3BRCtKEgsKY7HsAy65sIbFRP15xDUWUk1mzslYKXqaZ9ITGHD5eRpxaFLWixsycx8AQSYHl14Y6aGZWnBAYlBJlmCCfMsQeqsg4zu8csf9DeOQBxvhnB6XYiASrTRaNTVGkC@tlkqbpsWI7/@1H@i@XifbpSqs12KhiWwMlR1Jhd4tFI22gtgS6XCtl14p1/Px5PclVuDxfHnySR7Mbw "OCaml – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 63 bytes
```
(_:r)!(a:s)=a:s!r
_!_=[]
f s=([' '|even$length s]++reverse s)!s
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/XyPeqkhTUSPRqljTFkgoFnHFK8bbRsdypSkU22pEqyuo16SWpeap5KTmpZdkKBTHamsXAQWKilMVijUVi//nJmbmKdgqpORzKQBBQWlJcEmRT56CikKaglJiUnJKalp6RqYSPsksbLIeQMfl6yiE5xflpCjiVIBH3tHJ2cXVzd3D08vbx9fPPyAwKDgkNCw8IjIKm2oFxRglZRVVNXUNTS1tHV09fQNDI2MTUzNzC0sraxtbO3sH3OZFx8TExsUnIPyTnZObl19QWFRcUlpWXlFZVV1TW4fN0gDs7sYmCjRF6T8A "Haskell – Try It Online") Usage: `f "some string"`.
For odd strings like `abcdefghi`, the function `f` passes the string and its reversal to the function `!`, which alternates taking chars from both strings. For even strings this does not work, and we need to append a dummy character first to get the offset right.
[Answer]
# C, 69 bytes
```
c,l;f(char*s){l=strlen(s);for(c=0;c<l;++c)putchar(s[c&1?l-l%2-c:c]);}
```
Pretty simple. Walks the string, printing either the current character or the opposite one.
### Ungolfed and explained:
```
f(char *str) {
    int len = strlen(str);      // Get the total length
    for(int c = 0; c<len; ++c)  // Loop over the string
        putchar(s[              // Print the char that is,
            c & 1               // if c is odd,
                ? l - l % 2 - c // c chars from the end (adjusting odd lengths),
                : c             // and at index c otherwise
        ]);
}
```
[Answer]
## Mathematica, 82 bytes
```
""<>(f=Flatten)[{#&@@#,Reverse@Last@#}&@f[Characters@#~Partition~UpTo@2,{2}],{2}]&
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 21 bytes
```
DgÉi¶«}2ô.BøRćR‚˜øJ¶K
```
[Try it online!](https://tio.run/##ATMAzP8wNWFiMWX//0Rnw4lpwrbCq30yw7QuQsO4UsSHUuKAmsucw7hKwrZL//9hYmNkZWZnaGk "05AB1E – Try It Online")
I'm guessing the reason this wasn't done in 05AB1E yet is because it's gross...
Yet another time the `zip` function's auto-drop-last-element hurts instead of helps.
*P.S. If you have improvement suggestions on my answer, post your own; it's likely enough of an improvement to warrant you getting the points. I am pretty ashamed of this answer.*
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 18 bytes
**Solution:**
```
{x[w:&2!!#x]:x@|w}
```
[Try it online!](https://tio.run/##y9bNz/7/v7oiutxKzUhRUbki1qrCoaa8VskjNScnX0chPL8oJ0VR6f9/AA "K (oK) – Try It Online")
**Examples:**
```
> {x[w:&2!!#x]:x@|w}"Hello, World!"
"HdlroW ,olle!"
> {x[w:&2!!#x]:x@|w}"Hello World!"
"H!llooW rlde"
```
**Explanation:**
Interpretted mostly right-to-left, find the odd-indices characters, reverse them and put them back into the string
```
{x[w:&2!!#x]:x@|w} / solution
{                } / lambda function with implicit parameter x
         #x        / count x,    #"Hello, World!" -> 13
        !          / til,        !13 -> 0 1 2 3 4 5 6 7 8 9 10 11 12
      2!           / 2 modulo,   2!0 1 2 3 4 5 6 7 8 9 10 11 12 -> 0 1 0 1 0 1 0 1 0 1 0 1 0
     &             / where true, @0 1 0 1 0 1 0 1 0 1 0 1 0 -> 1 3 5 7 9 11
   w:              / store in variable w
               |w  / reverse w,  |1 3 5 7 9 11 -> 11 9 7 5 3 1
             x@    / index into x at these indices
 x[        ]:      / assign right to x at these indices
```
[Answer]
# J, 26 bytes
```
[:,@,./(0 1$~#)]`(|.@])/.]
```
### ungolfed
```
[: ,@,./ (0 1 $~ #) ]`(|.@])/. ]
```
### explanation
* `(0 1$~#)]`(|.@])/.]` Use Key `/.` to split the input into the even/odd groups: `(0 1$~#)` creates the group definition, by repeating 0 and 1 cyclically to the length of the input. We use the gerundial form of Key for its main verb `]`(|.@])`, which applies the identity to the first group and reverses the second group: `(|.@])`.
* Now that we have the two groups, the odd one reversed, we just zip them together and flatten: `,@,./`
[Try it online!](https://tio.run/##PYpJC4JAGEDv/oqvBVQYRrsKgvuejfsSQpBKxMCAXqu/boLg4V3ee@9lnEFVQIaV5a4gDWFJkOFy/p3E7iF8sNaJEu4WkTti4EdV4QHBV4Fx5rjh@WIwAu8NlDIEFZtof@AhNjB4PZ1YBYhROhz2kWyR7EI3TMt2XM8Pwuga30iSZnlRVnXTbqfemrVdurmfhmTtURJkXuFUVmMsfw "J – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~8~~ 6 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ó oÔrí
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=8yBv1HLt&input=ImFiY2RlZmdoaSI)
```
ó oÔrí     :Implicit input of string
ó          :Uninterleave
  o        :Modify last element
   Ô       :  Reverse
    r      :Reduce by
     í     :  Interleaving
```
[Answer]
# [Thunno 2](https://github.com/Thunno/Thunno2), 3 [bytes](https://github.com/Thunno/Thunno2/blob/main/docs/codepage.md)
```
^rI
```
[Try it online!](https://Not-Thonnu.github.io/run#aGVhZGVyPSZjb2RlPSU1RXJJJmZvb3Rlcj0maW5wdXQ9SGVsbG8lMkMlMjBXb3JsZCEtJTNFSGRscm9XJTIwJTJDb2xsZSElMEFIZWxsbyUyMFdvcmxkIS0lM0VIIWxsb29XJTIwcmxkZSUwQUFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaLSUzRUFaQ1hFVkdUSVJLUE1OT0xRSlNIVUZXRFlCJTBBJTIwISUyMiUyMyUyNCUyNSUyNicoKSolMkIlMkMtLiUyRjAxMjM0NTY3ODklM0ElM0IlM0MlM0QlM0UlM0YlNDBBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWiU1QiU1QyU1RCU1RV8lNjBhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5eiU3QiU3QyU3RH4tJTNFJTIyJTIwJTdEJTVDJTIyJTdCJTI0eSUyNncodSpzJTJDcS5vMG0yazRpNmc4ZSUzQWMlM0NhJTNFXyU0MCU1REIlNUJEWUZXSFVKU0xRTk9QTVJLVElWR1hFWkMlNUNBJTVFJTNGJTYwJTNEYiUzQmQ5ZjdoNWozbDFuJTJGcC1yJTJCdCl2J3glMjV6JTIzJTdDIX4lMjIlMEFQLSUzRVAlMEFBQi0lM0VBQiUwQXh5ei0lM0V4eXomZmxhZ3M9Qw==)
#### Explanation
```
     # Implicit input
^    # Uninterleave into two parts and push them separately to the stack
     #   "Hello, World!"  ->  "Hlo ol!", "el,Wrd"
     #   "ABCDEF"         ->  "ACE", "BDF"
     #   "P"              ->  "P", ""
 r   # Reverse the top of stack (second part from before)
     #   "Hello, World!"  ->  "Hlo ol!", "drW,le"
     #   "ABCDEF"         ->  "ACE", "FDB"
     #   "P"              ->  "P", ""
  I  # Interleave the two strings together
     #   "Hello, World!"  ->  "HdlroW ,olle!"
     #   "ABCDEF"         ->  "AFCDBE"
     #   "P"              ->  "P"
     # Implicit output
```
[Answer]
# Python 3, ~~93~~ 87 bytes
```
lambda s:"".join("".join(t)for t in zip(s[::2],reversed(s[1::2])))+("",s[-1])[len(s)%2]
```
[Answer]
# [Perl 6](https://perl6.org), ~~63 58~~ 55 bytes
```
{[~] .comb[{flat roundrobin (0,2...^*>=$_),[R,] 1,3...^*>=$_}]}
```
[Test it](https://tio.run/nexus/perl6#dY9nVyoxEIa/51cERdyFsDTFsoL07r30XtwSYDFs1i0IIvx1buB48ZMnk3My75N5Z8axMFxFBUUEyw30KFTFMHbYDvYjKCh0KQ@2UyLZ0KSOrppU1nTIBVFYEISxNx5zT3g0qKMRDKHIWdqNdgdmlbCxZcMYJJqOLY4XZiY2uMCwEeAFk9rU5MK8CBzWvMn@icAgkg59pyIRTKn5Xe@PQ26o6YZjoyFeG1ixscrDLYBQs@BxWO4EeQT/UwRPCtgdJFlR8XQ214A0V6ZYnckaAGdxAaSFMmdPVZMBKGBCKIIdahLVBQoqMWkHIkoIdn3DM3OxhEGWYACSqXQmm8sXiqVy5eXP32qt3mi22p1urw@S/XQ32843i/VylaFKrdQotHKdTC8FAHRdXLqvPNcc7/UhvxAIhsKRm9vo3f3Do/gUiz8nfvcdDEfjyevPGm9kqVPj3bRsZ/Wx3nxuv3Z7AHcXW/fG88E5Xgu9CzS4DL/daNHZPX5UnqT4JDFKDTK9XKfQKjUqNeb/Ui83i@18N9tPD5Pj59eYLKoP07v57SJCQnrA8Js@m19dr68@L79cewCq7LDljwFY0@P9Bw "Perl 6 – TIO Nexus")
```
{[~] flat roundrobin .comb[{0,2...*},{$_-1-$_%2,*-2...*}]}
```
[Test it](https://tio.run/nexus/perl6#dY/ZVuJAEIbv@ykaBUwgCYuKSwTZdx32HTFLB4JNOmZBMMKrMw3jOFdzuvqcrv/r@qvKtRFcJwRFBKstDCpERTB58Mb7KdSw5ECLuIZqEVk3oKCQlTz2olxcEITQjvP8Mz7G@2eBOBfi/2jT3YG6pB1kOzAJsW4gm2GFuYVMJjJpR1jBIg6xmDgrApf27dB/IjCxZMDwqUgEGrG@6/kUZCa6YboON0EbEykOUlnoAQh1Gx7nZE6Q5eBfysGTAnYHSVZUpM0XOpAWiobUuawD8CMugbRUFvSp6jIAZYQx4WCfWFj1gbKKLdKHHMEY@b7hD/PRhEKaIAAy2Vy@UCyVK9Va/en5V6PZane6vf5gOAKZUW5Q6JU6lVatQVG9WW2Xu8V@fpgFAPrOzv2B4AXDhsIcL0Sisfjl1XXi5vbuXnxIph7T//cdT6Yvs9d/a7zhlUHMd8t23PXHZvvpfe32AO7OPP82@MG4IZt7F0h0FX@70hPzW3SvPEipWXqaHeeHxX65W23Xm9T/qVXrVHqlQWGUm2ReHl@TsqjeaTeL6@UljhkRk7fCDru@2AQ@z798ewAa9NDljwFo0@P9DQ "Perl 6 – TIO Nexus")
```
{[~] flat roundrobin .comb[{0,2...*},{[R,] 1,3...^$_}]}
```
[Test it](https://tio.run/nexus/perl6#dY/XduIwEIbv9RQiIcQGYVpCigOh9@zSe4mLDCbGclwIxDGvzgpONnu1ZzTn6J9P84/GsTDcJjmJB5s9DEhExjB1dCeHGVQ0wYYmcXTZJKKqQ04iG3HiRlGc47igh9xJG81gDCWonPsX3sw7UouMjS0bpqCm6thiWG5pYoOJTDsRljOJTUwmzvLAoUO79B0PDE3QYejcxAOFmN/94TRkpqpuODaa4p2BJRvLLHQBhKoFT59kzpBF8C9F8FwB3lEQJRkry5UKhJWkYHkpqgD8FNdAWEsrepVVEYAK1jSC4ICYmuwDFVkzyQAiomnY9w1/mI8KCqnAAGRz@UKxVK5Ua/XGy6/fzVa70@31B8PRGGTH@WGxX@5W2/UmRY1WrVPplQaFUQ4A6Lu49F8Frhk2GEJhLhKNxRM3t8m7@4dH/imVfs7833cync0Xr//WeNM2OjHeTct2th@7/af75R0A9C5c/z7wwThBC71zJLqJv92oyeU9fpSehPQiM8tNCqPSoNKrdRot6v/Srner/fKwOM5Ps/Pn15TIyw/K3ep2ndBiesQImyGb3V7vrj4vv3wHAJo06PKnA@jQU/4B "Perl 6 – TIO Nexus")
```
{  # bare block lambda with implicit parameter ｢$_｣
  [~]                 # reduce using string concatenation operator
    flat              # make the following a flat list
    roundrobin        # grab one from each of the following 2 lists,
                      # repeat until both are empty
    .comb\            # split the input into graphemes (implicit method call)
    [                 # index into that sequence
      { 0, 2 ... * }, # code block producing every non-negative even number
      {               # code block producing reversed odd numbers
                      # (｢$_｣ here contains the number of available elements)
        [R,]          # reduce with reversed comma operator
                      # (shorter than ｢reverse｣)
        1, 3 ...^ $_  # odd numbers stopping before it gets
                      # to the number of input elements
      }
    ]
}
```
I had to use [`roundrobin`](https://docs.perl6.org/routine/roundrobin) rather than [`zip`](https://docs.perl6.org/routine/zip), because [`zip`](https://docs.perl6.org/routine/zip) stops as soon as one of the input lists is exhausted.
[Answer]
# Mathematica, 62 bytes
takes as input a string
```
(s=Characters@#;Row@Riffle[s[[;; ;;2]],Reverse@s[[2;; ;;2]]])&
```
[Try it online!](https://tio.run/nexus/mathics#S7P9r1Fs65yRWJSYXJJaVOygbB2UX@4QlJmWlpMaXRwdbW2tYG1tFBurE5RaBpRPdQCKGcEEYzXV/gcUZeaVKDikKTgoeaTm5OTrKITnF@WkKCr9BwA "Mathics – TIO Nexus")
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 24 bytes
*Bytes golfed thanks to @Adám*
```
A⊣A[i]←⌽A[i←2×⍳⌊2÷⍨⍴A←⎕]
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKPd6b/jo67FjtGZsY/aJjzq2QtkARlGh6c/6t38qKfL6PD2R70rHvVucQRJ902NBen578Sl7pGak5OvoxCeX5SToqjOBROBCQAA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# GNU APL 1.2, 24 bytes
```
R[X]←⌽R[X←2×⍳⌊.5×⍴R←⍞]◊R
```
APL works from right to left. `⍴R←⍞` assigns user input to `R` and then evaluates its length. Halve this by multiplying by `.5` and apply `⌊` floor function. `⍳` returns all numbers from 1 to the argument.
APL operates on arrays, so `2×` the array we just got from `⍳` doubles each element, giving us just the even indices (1-indexed, so relies on `⎕IO` being 1).
When accessing multiple indices of a vector, APL gives the elements at those indices in a vector. `R[X←2×⍳⌊.5×⍴R←⍞]` gives just the even-indexed elements. `⌽` reverses the elements. Then, assign the reversed values back to the even indices (assigning these indices to `X` saves 6 bytes).
`◊` is the statement separator. After the reversing is done, evaluate `R` to print the result.
]