Code Golf
string sorting add tag
Given a string as an input (which can be any acceptable/convenient format in your language), implement pendulum encoding. The test cases are split into individual items (which aren't quoted) for a visually appealing explanation.
## How do I do that?
The current **iteration index** starts at `0`.

* If the iteration index is even, append the current item onto the output string.
* If the iteration index is odd, prepend the current item onto the output string.

## An example
The input is [a b c d e f g].
Note that the letters a-g are individual one-character strings, to prevent confusion from the iteration index.
N: the iteration index

N:0 Out:      [a]
N:1 Out:    [b a]
N:2 Out:    [b a c]
N:3 Out:  [d b a c]
N:4 Out:  [d b a c e]
N:5 Out:[f d b a c e]
N:6 Out:[f d b a c e g]
The output should be `[f d b a c e g]`.
# Another example
The input is [u d l n u e m p].

N:0 Out:        [u]
N:1 Out:      [d u]
N:2 Out:      [d u l]
N:3 Out:    [n d u l]
N:4 Out:    [n d u l u]
N:5 Out:  [e n d u l u]
N:6 Out:  [e n d u l u m]
N:7 Out:[p e n d u l u m]
## Test cases
[Here]('s a sample program doing this encoding.

Take note that the characters in the string aren't always unique.
Your output *has* to be flattened.

[a,b,c,d,e,f,g]   -> [f,d,b,a,c,e,g]
[]                -> []
[a]               -> [a]
[a,b,c,d]         -> [d,b,a,c]
[a,b]             -> [b,a]
[a,b,d]           -> [b,a,d]
[a,b,a,c,b,c]     -> [c,c,b,a,a,b]
[a,a,b,b,c,c]     -> [c,b,a,a,b,c]
[u,d,l,n,u,e,m,p] -> [p,e,n,d,u,l,u,m]
Top Answer APL (Dyalog Extended)
# [APL (Dyalog Extended)], 11 [bytes]( "When can APL characters be counted as 1 byte each?") ([SBCS]( ".dyalog files using a single byte character set"))


[Try it online!][TIO-k88l7mbf] (Empty case works offline, but TIO hasn't been updated.)

`-\` alternating sum

`` `∘`` of

`⍳` **ɩ**ndices

`∘` of

`≢` the length

`⍋` graded (indices that would sort)

`⍛` before

`⊇` being used to select from

`⊢` the argument

[APL (Dyalog Extended)]:
[TIO-k88l7mbf]: "APL (Dyalog Extended) – Try It Online"
Answer #2 Python 3
# [Python 3] REPL, 25 bytes


[Try it online!][TIO-khqsf6k8]

## Explanation
    _[           ::  ]          substring
                   -2            of every other item, backwards, from
        len(_)                    the length
              %2                  mapped even => 0
                                          odd => 1
      ~(        )                 mapped 0 => -1 (last element)
                                         1 => -2 (second-last)
                      +        joined with
                       _[:: ]    substring
                           2      of every other item

[Python 3]:
[TIO-khqsf6k8]: "Python 3 – Try It Online"
Answer #3
# [Jelly], 7 bytes


[Try it online!][TIO-khpc4b88]

[TIO-khpc4b88]: "Jelly – Try It Online"

## Explanation

    ŒœṚ;¥@/   Main monadic link
    Œœ        Split into odd and even indices
          /   Fold over
         @      Reverse arguments
        ¥         Dyad (
      Ṛ             Reverse [left argument]
       ;            Join [with right argument]
        ¥         )
Answer #4
# [Runic Enchantments], 30 bytes


[Try it online!][TIO-knop1sh7]

[Runic Enchantments]:
[TIO-knop1sh7]: "Runic Enchantments – Try It Online"

Or if just squashing the inputs together with no joiner is allowed:

# [Runic Enchantments], 17 bytes


[Try it online!][TIO-knop5nd4]

[Runic Enchantments]:
[TIO-knop5nd4]: "Runic Enchantments – Try It Online"

In order for Runic to "read all input" the natively results in a pendulum encoding of said inputs.[^1] The only fiddly bit is whether the stack is in *forward* order or *reverse* order, depending on if there were an even or odd number of values in the input.

In general, nothing special going on here. Read-input loop followed by a length-is-even check to reverse (or not) the stack, then a print-with-joiner loop or print-all-and-terminate.

[^1]: Because `i`nput results in `NOP` if the input buffer is empty, the only safe place to store the current length of the stack prior to `i` is the bottom of the stack (A `S`wap command would corrupt the stack if there was no input to read!). Both `}` and `r` could be used, but `r` results in the desired behavior.
Answer #5
# TeX, 91 bytes

This has restricted input, only `[A-Za-z]` work, everything else is considered the end of the string. Input must be of the form `\iftrue,<string>\relax\fi.`.


Complete script running all test cases (I've added `><` around the output to make it easier to see that it works as intended):



\def.{} % reset state

\def.{} % reset state

\def.{} % reset state

\def.{} % reset state

\def.{} % reset state

\def.{} % reset state

\def.{} % reset state

\def.{} % reset state




Enter question or answer id or url (and optionally further answer ids/urls from the same question) from

Separate each id/url with a space. No need to list your own answers; they will be imported automatically.