[Question]
  [
[Related but very different.](https://codegolf.stackexchange.com/questions/64330/reverse-boustrophedon-text)
A [boustrophedon](https://en.wikipedia.org/wiki/Boustrophedon) is a text where every other line of writing is flipped or reversed, with reversed letters.
In this challenge, we will just reverse every other line, but leave the actual characters used intact. You may chose which lines to reverse, as long as it is every other one.
You may take the text in any suitable format as long as you support zero or more lines of printable ASCII, each with zero or more characters.
### Examples:
```
["Here are some lines","of text for you","to make a","boustrophedon"]:
["Here are some lines","uoy rof txet fo","to make a","nodehportsuob"] or ["senil emos era ereH","of text for you","a ekam ot","boustrophedon"]
["My boustrophedon"]:
["My boustrophedon"] or ["nodehportsuob yM"]
[]:  
[]
["Some text","","More text","","","Last bit of text"]:
["Some text","","More text","","","txet fo tib tsaL"] or ["txet emoS","","txet eroM","","","Last bit of text"]
```
  
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 4 bytes
```
⊢∘⌽\
```
The input is a vector of character vectors.
`⌽` is a function that reverses a vector (when `⌽` is applied monadically).
`⊢` is "*dex*" - a function that returns its right argument. When composed (`∘`) with another function `f` it forces the latter to be monadic as `A ⊢∘f B` is equivalent to `A ⊢ (f B)` and therefore `f B`.
`\` is the *scan* operator. `g\A B C ...` is the vector `A (A g B) (A g (B g C)) ...` where `g` is applied dyadically (infix notation). Substituting `⊢∘⌽` for `g` it simplifies to:
```
A (A ⊢∘⌽ B) (A ⊢∘⌽ (B ⊢∘⌽ C)) ...
A (⌽B) (⌽⌽C) ....
A (⌽B) C ....
```
The reversals at even positions (or odd, depending on how you count) cancel out.
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbhEddix51zHjUszcGyFf3SC1KVUgE4uL83FSFnMy81GJ1BfX8NIWS1IoShbT8IoXK/FKgSEm@Qm5iNlApkJ2UX1pcUpRfkJGakp@nzpWm86irSd23UgFdXMHgUe8WkJw6AA "APL (Dyalog Classic) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 26 bytes
```
zipWith($)l
l=id:reverse:l
```
[Try it online!](https://tio.run/##dYy9DoIwFIV3nuKkcYAEfQASdhdmB2WocCsNpbdpixEf3lrcPckZzk@@SYaZjEmqvaW3dhcdp/JQmcK0emw8PckHakxapLZosUjXoXRe24gTVFUg64qrOJMnyOzAC8FoS0HUEKwQ6RWh2GPjda8iZ8qcz3u48xqiZzfRyFb0P1ydcd2GP1OPPn0GZeQjpOPg3Bc "Haskell – Try It Online") Usage example: `zipWith($)l ["abc","def","ghi"]` yields `["abc","fed","ghi"]`.
**Explanation:**
`l` is an infinite list of functions alternating between the `id`entity function and the `reverse` function.
The main function zips `l` and the input list with the function application `$`, that is for an input `["abc", "def", "ghi"]` we get `[id$"abc", reverse$"def", id$"ghi"]`.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 4 bytes
```
z*İ_
```
Takes and returns a list of strings (the interpreter implicitly joins the result by newlines before printing).
The first string is reversed.
[Try it online!](https://tio.run/##yygtzv7/v0rryIb4////RysZGinpKBmbAAlTMyBhbgEkLA2UYgE "Husk – Try It Online")
## Explanation
```
z*İ_  Implicit input.
  İ_  The infinite list [-1,1,-1,1,-1,1..
z     Zip with input
 *    using multiplication.
```
In Husk, multiplying a string with a number repeats it that many times, also reversing it if the number is negative.
[Answer]
# JavaScript (ES6), Firefox, 43 bytes
This version abuses the sort algorithm of **Firefox**. It generates garbage on Chrome and doesn't alter the strings at all on Edge.
```
a=>a.map((s,i)=>[...s].sort(_=>i&1).join``)
```
### Test cases
```
let f =
a=>a.map((s,i)=>[...s].sort(_=>i&1).join``)
console.log(f(["Here are some lines","of text for you","to make a","boustrophedon"]))
console.log(f(["My boustrophedon"]))
console.log(f([]))
```
Or [Try it online!](https://tio.run/##hYxBCsMgEEX3PYW4KAqp0AOYdTc9QQiJTcbWJDrimNKc3rruposPj8fjL@ZtaEou5gtFN0PyGFY4itXF6NYob6IQ1Dip204pRb0iTFkMunXnq1QLujCOskwYCDdQGz6FFR2/QQJm6gg9sM0FIN5wtCzDJzOLiR24V5ORebPWtPIDd8oJ4wtmDLyX8vT7ej/Y36iq8gU "JavaScript (SpiderMonkey) – Try It Online") (SpiderMonkey)
---
# JavaScript (ES6), 45 bytes
```
a=>a.map(s=>(a^=1)?s:[...s].reverse().join``)
```
### Test cases
```
let f =
a=>a.map(s=>(a^=1)?s:[...s].reverse().join``)
console.log(f(["Here are some lines","of text for you","to make a","boustrophedon"]))
console.log(f(["My boustrophedon"]))
console.log(f([]))
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 10 bytes
```
⌽¨@{2|⍳≢⍵}
```
Works both ways:
[Try it online!](https://tio.run/##Fcs9DsIwDAXgnVN4y8TCCRi5RkqctjSJQ5JCw8@KhEQlzsDEjhhZOEouUszgT096z9KbucrSUD1Nulzu5fb5PpfHxamMr3J9lPF95kLIai1AKNRs3bTspjOsdcT6bWBj6tndfmDzQcy0WGFAkHyRLIJpHUbuSEPCIYGmAJn@P4nAyo6nnCvqYwrkG1TkxA8 "APL (Dyalog Unicode) – Try It Online") with `⎕IO←1`
[Try it online!](https://tio.run/##Fcs9DsIwDAXgnVN4y4SEOAEjTJwhpU5bmtYlSUvDz4qERBELF2BiR4wsHCUXCWbwpye9Z9noceqlpiyG632xDKfbJCo2XD7f52w/PYThFc6PMLyPMSohk5UAkaJis7xg16Vmq5rYZmNY61q22/as34mREnM0CJLPUoWgixotd6TAYe9AkQFP/x9HUMmSp5wTaq0z1OSYUi1@ "APL (Dyalog Unicode) – Try It Online") with `⎕IO←0`
### How it works:
```
⌽¨@{2|⍳≢⍵} ⍝ tacit prefix fn
   {   ≢⍵} ⍝ Length of the input
      ⍳    ⍝ generate indexes from 1 (or 0 with ⎕IO←0)
    2|     ⍝ mod 2; this generates a boolean vector of 0s (falsy) and 1s (truthy)
  @        ⍝ apply to the truthy indexes...
⌽¨         ⍝ reverse each element
```
[Answer]
# Perl 5, 17 + 2 (-pl) = 19 bytes
odd lines reversed
```
$_=reverse if$.%2
```
even lines reversed
```
$_=reverse if$|--
```
After @Martin's comment : input needs to have a trailing linefeed.
[try it online](https://tio.run/##K0gtyjH9/18l3rYotSy1qDhVITNNRU/V6P//xCSu5BQurvQMrn/5BSWZ@XnF/3ULcgA)
[Answer]
# [Haskell](https://www.haskell.org/), 27 bytes
```
foldr((.map reverse).(:))[]
```
[Try it online!](https://tio.run/##dYxNDsIgFIT3nmLCChLtAUy6d9MTVBbYPmxTyiNAjb28SN07ySzmJ99k0kLOFdvei2U3Rimb1QREelFMpBp5VarXZTWzR4s6dZAhzj6jgVUnVPXoxY0iwVQnXglu9pTEGYItMr0zLEfsvB1V5kpZ6vkID95SjhwmGtkL/cOdK67b8WfS0OUzWGeeqVyGEL4 "Haskell – Try It Online")
## [Haskell](https://www.haskell.org/), 30 bytes
```
f(a:b:c)=a:reverse b:f c
f a=a
```
[Try it online!](https://tio.run/##dYxNCoMwFIT3nmLISkF6gED23XgCcfG0LyiavJDEUk@fxu47MIv54Vsp7XwcpdiW9KyXzpCO/OaYGLO2WBoLMlQcbR4GjsKANsTNZzxguwZVI0b15Mig6iSOcWyek@qhxCLzJ8NKxCXnXWWplL2e7zDLmXKUsPJLvJp@uL7ihgt/pglT@QI "Haskell – Try It Online")
Recursion FTW.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), ~~5~~ 4 bytes
```
εNFR
```
[Try it online!](https://tio.run/##yy9OTMpM/f//3FY/t6D//6OVPFKLUhUSgbg4PzdVISczL7VYSUcpP02hJLWiRCEtv0ihMr8UKFKSr5CbmA1UCmQn5ZcWlxTlF2SkpuTnKcUCAA "05AB1E – Try It Online")
**Explanation**
```
ε     # apply to each element (row)
 NF   # index times do:
   R  # reverse
```
[Answer]
# [R](https://www.r-project.org/), 85 bytes
```
for(i in seq(l<-strsplit(readLines(),"")))cat("if"(i%%2,`(`,rev)(l[[i]]),"\n",sep="")
```
[Try it online!](https://tio.run/##Fc1BCsIwEIXhfU8xBAoTSDeu9QbeoBYa7YQOppk6SUVPH@Pi7T7er7UGUWTgBJleGM9DLpr3yAWV/HLlRBmtM8Za@/AFDQeD3PcnN@PslN4W4zjyNDVzS8Zl2i8N15WUwLdl2Qji/6aTAIU@BVoRvnJ0RWDzz8bgLkfLyr7SIqn@AA "R – Try It Online")
Input from stdin and output to stdout.
Each line must be terminated by a linefeed/carriage return/CRLF, and it prints with a corresponding newline. So, inputs need to have a trailing linefeed.
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), ~~17~~ 14 bytes
**Solution:**
```
@[;&2!!#x;|]x:
```
[Try it online!](https://tio.run/##y9bNz/7/3yHaWs1IUVG5wromtsJKQ8kjtShVIRGIi/NzUxVyMvNSi5WslfLTFEpSK0oU0vKLFCrzS4EiJfkKuYnZQKVAdlJ@aXFJUX5BRmpKfp6S5v//AA "K (oK) – Try It Online")
**Example:**
```
@[;&2!!#x;|]x:("this is";"my example";"of the";"solution")
("this is"
"elpmaxe ym"
"of the"
"noitulos")
```
**Explanation:**
Apply `reverse` at odd indices of the input list:
```
@[;&2!!#x;|]x: / the solution
            x: / store input as variable x
@[;      ; ]   / apply @[variable;indices;function] (projection)
          |    / reverse
       #x      / count (length) of x, e.g. 4
      !        / til, !4 => 0 1 2 3
    2!         / mod 2, 0 1 2 3 => 0 1 0 1       
   &           / where true, 0 1 0 1 => 1 3
```
**Notes:**
* switched out `&(#x)#0 1` for `&2!!#x` to save 3 bytes
[Answer]
# [APL (Dyalog)](https://www.dyalog.com/), 12 bytes
```
⍳∘≢{⌽⍣⍺⊢⍵}¨⊢
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///P@1R24RHvZsfdcx41Lmo@lHP3ke9ix/17nrUtehR79baQyuAjP//H/WuSlNQ90gtSlVIBOLi/NxUhZzMvNRidQX1/DSFktSKEoW0/CKFyvxSoEhJvkJuYjZQKZCdlF9aXFKUX5CRmpKfp86lrq2trc4FNu5RV5N6YlIyqljvGgA "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~40~~ 36 bytes
*-4 bytes thanks to [@Mr.Xcoder](https://codegolf.stackexchange.com/users/59487/mr-xcoder)*
```
def f(k):k[::2]=map(reversed,k[::2])
```
[Try it online!](https://tio.run/##JY2xCsQgEAX7fMViE4VwRUoh/f1DSGFwJZ7RFTVy@XrPcMWDxzAw8S4Hhbk1jQYMd0K6Vcp5W7yKPGHFlFFPfyaagwVW9saEoPoyeYTTBsxsYmSg4LeAoQQ3XZ0UAq9cV/vf6colUTxQU2Db8KSGmGwo8JRO5XetoMpxfH3IBn7aXHgVYgIn2g8 "Python 2 – Try It Online")
Outputs by modifying the input list
---
# [Python 2](https://docs.python.org/2/), 43 bytes
```
f=lambda k,d=1:k and[k[0][::d]]+f(k[1:],-d)
```
[Try it online!](https://tio.run/##DYpBCsMgEADvfcXiKaEWmh4F7/2DeDDsSsJGV4yB5vXWw8AwTLnbJvnTe7RHSCsGYI12MQwho2P39s4Y9P4ZJ3aL8fqFc2ew4NSXKkEYnJIIjj3TqbSSCI1@DaJUuOUapQmkwGMdvsp1tiplI5Ss/KPUPY934rn/AQ "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~5~~ 4 bytes
```
U¹ƭ€
```
[Try it online!](https://tio.run/##y0rNyan8/z/00M5jax81rfl/uD3y//9oJY/UolSFRCAuzs9NVcjJzEstVtJRyk9TKEmtKFFIyy9SqMwvBYqU5CvkJmYDlQLZSfmlxSVF@QUZqSn5eUqxAA "Jelly – Try It Online")
Thanks *HyperNeutrino* for -1 bytes! (actually because I never knew how `ƭ` works due to lack of documentation, this time I got lucky)
[Answer]
# [Alumin](https://github.com/ConorOBrien-Foxx/Alumin), 66 bytes
```
hdqqkiddzhceyhhhhhdaeuzepkrlhcwdqkkrhzpkzerlhcwqopshhhhhdaosyhapzw
```
[Try it online!](https://tio.run/##LYpbCsAgDMD@vc1eByrWUek2qyJiL98xWT4CgcDV7viYEebMEVHJh0EfCKFpEC4X@Y6ZuZAKa5idk9T/SnUQiHYzqHi6Zd12N328 "Alumin – Try It Online")
```
FLAG: h
hq
  CONSUME A LINE
  qk
  iddzhceyhhhhhdaeuze
  pk
  rlhcw
  REVERSE STACK CONDITIONALLY
  dqkkrhzpkzerlhcwqops
  OUTPUT A NEWLINE
  hhhhhdao
syhapzw
```
[Answer]
# [J](http://jsoftware.com/), 9 bytes
```
(,|.&.>)/
```
Reduce from right to left, reversing all strings in the result and prepending the next string as is.
[Try it online!](https://tio.run/##hY29CsJAEIT7fYqpjAE5wVZjbRErH0AuZo9Eza3cjxjw3c@LxNqBgWEY5rumZCqF5eqtFmpfrhNfOgE/2Y0w2G3VeQMr0aJl01umAzuGzvYyMO658iQGgV8BRhxGiRQEg77lGTUSfXDy6LgVSyV9z4tqVkF/YKeJMV0THcX9ItXaBzR9wAymMn0A)
We can do **6** using [ngn’s approach](https://codegolf.stackexchange.com/a/150153/74681), but there will be extra spaces:
```
]&|./\
```
[Try it online!](https://tio.run/##dY0xC8IwFIT39ytusnSJ4CrdHXRytUhqX2jV5pXkBRT87zEVHT04OI7ju2vOrjFoVy@zPmW@DAKHdmvOG3hJHj270TPtODBscZSJcS9VJHFQfiicBDwlkQomeysz6iRFDTIP3Iunmj7YqllU0d@P44JeiEQHCb9IexsV3aj4/lGd3w)
[Answer]
# T-SQL, 65 bytes
Our standard input rules allow SQL to [input values from a pre-existing table](https://codegolf.meta.stackexchange.com/a/5341/70172), and since SQL is inherently unordered, the table must have row numbers to preserve the original text order.
I've defined the table with an identity column so we can simply insert lines of text sequentially (not counted toward byte total):
```
CREATE TABLE t 
    (i int identity(1,1)
    ,a varchar(999))
```
So to select and reverse alternating rows:
```
SELECT CASE WHEN i%2=0THEN a
ELSE reverse(a)END
FROM t
ORDER BY i
```
Note that I can save 11 bytes by excluding the `ORDER BY i`, and that is *likely* to return the list in the original order for any reasonable length (it certainly does for the 4-line example). But SQL only *guarantees* it if you include the `ORDER BY`, so if we had, say, 10,000 rows, we would definitely need this.
[Answer]
# [V](https://github.com/DJMcMayhem/V), 4 bytes
```
òjæ$
```
[Try it online!](https://tio.run/##K/v///CmrMPLVP7/T0xKTuFKTUvP4MrMys7hys3LLwAA "V – Try It Online")
```
ò      ' <M-r>ecursively (Until breaking)
 j     ' Move down (breaks when we can't move down any more)
  æ$   ' <M-f>lip the line to the end$
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 44 bytes
```
lines.map: ->\a,$b?{a.put;.flip.put with $b}
```
[Try it](https://tio.run/##HYuxDgIhEAV7vuIVVyrlFV6irR9hs@iSI8ItgeXUGL8dT4tJppjJXOLYW2Wso71OPYaFq02UD9gfL7Qb3OlNNjedrI8h/wyPoDMG9@n9zIVBG1US4/8a8VB@KrwUvKQZFSS6b5lx0qoWyTPfZDFf "Perl 6 – Try It Online")
```
lines               # get the input as a list of lines
.map:
-> \a, $b? {        # $b is optional (needed if there is an odd number of lines)
  a.put;            # just print with trailing newline
  .flip.put with $b # if $b is defined, flip it and print with trailing newline
}
```
[Answer]
Comma delimited:
# [Stax](https://github.com/tomtheisen/stax), 12 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ü«äì╠▒╕█╬pεû
```
[Run and debug it](https://staxlang.xyz/#p=81ae848dccb1b8dbce70ee96&i=ABC,def,GHI,jkl,MNO,pqr,STU&a=1&m=1)
input: ABC,def,GHI,jkl,MNO,pqr,STU
Newline delimited:
# [Stax](https://github.com/tomtheisen/stax), 8 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
Çε÷┘)¼M@
```
[Run and debug it](https://staxlang.xyz/#p=80eef6d929ac4d40&i=ABC%0Adef%0AGHI%0Ajkl%0AMNO%0Apqr%0ASTU&a=1&m=1)
input: 
```
ABC
def
GHI
jkl
MNO
pqr
STU
```
output for both:
```
CBA
def
IHG
jkl
ONM
pqr
UTS
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 4 bytes
```
i↔ⁱ⁾
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/pfXa6kUFCUn1KanFpsxaX0cFen/aO2DY@amh5uW1D3cGc7UODhjm1Asvbh1gn/Mx@1TXnUuPFR477//6OjlTxSi1IVEoG4OD83VSEnMy@1WElHKT9NoSS1okQhLb9IoTK/FChSkq@Qm5gNVApkJ@WXFpcU5RdkpKbk5ynF6kQr@VYqYAiCxINBhoJMAuoCIt/8ImQuEPkkFpcoJGWWKEBtVIqNBQA "Brachylog – Try It Online")
Doesn't feel *entirely* honest to call this [generator](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/10753#10753) a 4-byter considering it costs 3 more bytes to [actually use it](https://codegolf.stackexchange.com/a/210297/85334).
```
i       Take an element from the input paired with its 0-index,
 ↔ ⁾    and reverse the element
  ⁱ     repeatedly
   ⁾    a number of times equal to the index.
```
[Answer]
# [Pyth](https://pyg.readthedocs.io), 6 bytes
```
.e@_Bb
```
**[Try it here!](https://pyth.herokuapp.com/?code=.e%40_Bb&input=%5B%22Here+are+some+lines%22%2C%22of+text+for+you%22%2C%22to+make+a%22%2C%22boustrophedon%22%5D&debug=0)**
* `.e` ~ Enumerated map. `k` is the index, `b` is the current element.
* `_Bb` ~ Bifurcate `b` with its reverse.
* `@` ~ Modular index in ^ with `k`.
[Answer]
# [Actually](https://github.com/Mego/Seriously), 7 bytes
```
;r'R*♀ƒ
```
Explanation:
```
;r'R*♀ƒ
;r       range(len(input))
  'R*    repeat "R" n times for n in range
     ♀ƒ  call each string as Actually code with the corresponding input element as input (reverse each input string a number of times equal to its index)
```
[Try it online!](https://tio.run/##S0wuKU3Myan8/9@6SD1I69HMhmOT/v@PVvJILUpVSATi4vzcVIWczLzUYiUdpfw0hZLUihKFtPwihcr8UqBISb5CbmI2UCmQnZRfWlxSlF@QkZqSn6cUCwA "Actually – Try It Online")
[Answer]
## [Alice](https://github.com/m-ender/alice), 13 bytes
```
M%/RM\
d&\tO/
```
[Try it online!](https://tio.run/##DcoxDoAgDAXQ3VN00ZVruBATZxbUGonAN1ASPX1leNvzMeysakezWjcck5PFqOrMhcl3FYkphsxVcZLwK3Si0IemAkr@7k03tCoFz8UH8g8 "Alice – Try It Online")
Input via separate command-line arguments. Reverses the first line (and every other line after that).
### Explanation
```
       At the beginning of each loop iteration there will always be zero
       on top of the stack (potentially as a string, but it will be
       converted to an integer implicitly once we need it).
M      Push the number of remaining command-line arguments, M.
%      Take the zero on top of the stack modulo M. This just gives zero as
       long as there are arguments left, otherwise this terminates the
       program due to the division by zero.
/      Switch to Ordinal mode.
t      Tail. Implicitly converts the zero to a string and splits off the
       last character. The purpose of this is to put an empty string below
       the zero, which increases the stack depth by one.
M      Retrieve the next command-line argument and push it as a string.
/      Switch back to Cardinal mode.
d      Push the stack depth, D.
&\R    Switch back to Ordinal mode and reverse the current line D times.
O      Print the (possibly reversed) line with a trailing linefeed.
\      Switch back to Cardinal mode.
       The instruction pointer loops around and the program starts over
       from the beginning.
```
[Answer]
# [Tcl](http://tcl.tk/), 61 bytes
```
proc B L {lmap e $L {expr [incr i]%2?"$e":"[string rev $e]"}}
```
[Try it online!](https://tio.run/##dYwxDsIwEAR7XrGyzAcoaZBSUcALIhdJuICF47PODkpk@e3GHRXFSqPd1aTJ1RqEJ3S4IbtlCCDohrQFQW/9JLDmeLooTeqs@pjE@ieEPtBkVCk1rCmi75DzlYQwtEReCM56igWZZyTaEmYW7Ly2JjGW4d2ujUdem5LDix7sSzGHn@6@4/9aTP0C "Tcl – Try It Online")
[Answer]
# [Standard ML (MLton)](http://www.mlton.org/), 51 bytes
```
fun$(a::b::r)=a::implode(rev(explode b)):: $r| $e=e
```
[Try it online!](https://tio.run/##TY5NCsMgEEb3PcUgLhTaCwh23Tv0J5h0pKHqiJqQQO@eGrvpYpjH8L6Pyd6dvCsUts1OgQujVK9UkrrC6KOjJ4qEs8ClMfRSKgU8fYCjxm02DgrmAhqu7IIJwdTJ5BHcGDCzIyNbjaWApQQrTfVSCLx5V7VyT1MuieILnxTY/bAXxoSlrF1MY9iLf5tgoDCYHbyJIGyADPoM@cFugckW7Jr9Fxa8fSe3Lw "Standard ML (MLton) – Try It Online") Usage example: `$ ["abc","def","ghi"]` yields `["abc","fed","ghi"]`.
**Explanation:**
`$` is a function recursing over a list of strings. It takes two strings `a` and `b` from the list, keeps the first unchanged and reverses the second by transforming the string into a list of characters (`explode`), reversing the list (`rev`), and turning it back into a string (`implode`).
[Answer]
# [Stacked](https://github.com/ConorOBrien-Foxx/stacked), 18 bytes
```
[{x i:x$revi*}map]
```
[Try it online!](https://tio.run/##DYrBCoMwEAXvfsU7CGn9BE8e@w@lh2g2GGzckF0lIv32NIeBYRhRu2zkan3fBWEsfaYzDL9o06dOo@8e5kWZYBvCkfANO4mBYQ@lovCccfHRijKi3drafOZDNHNayfFunvBwQVL9Aw "Stacked – Try It Online")
This simply reverses each string in the array according to its position.
## Alternative, 24 bytes
```
[:#':>#,tr[...$rev*]map]
```
Same approach, but generates indices manually.
[Answer]
# [Python 2](https://docs.python.org/2/), 45 bytes
```
lambda k:[r[::i%-2|1]for i,r in enumerate(k)]
```
[Try it online!](https://tio.run/##FYxBCsMgEEWvMggFhXTRLIXuewfrwpCRiNERHaGB3t3axYPP4/PKxQfldfjne5wubbuDqE01Wofbff0@rKcKYZlkwNwTVscoo7Kj1JBZemnECyuCmzRKCGfI2MQiyAPjh@EfuKhPwwTJxXmde6PeuFI5cKcsrFLjBw "Python 2 – Try It Online")
# [Python 2](https://docs.python.org/2/), 46 bytes
```
f=lambda k:k and[k[0][::len(k)%-2|1]]+f(k[1:])
```
[Try it online!](https://tio.run/##DYrLCsMgEAB/ZREKSltochR67z@IB4MrCT5WdAMN9N@th4FhmHrxTmUdI7yTy5t3EHUEV7yJ5mWN1gmLjOr2XH@Ltfcgo1m0VaO2o7AM0ogPNgQ36ZQR0lGwi4egAIxfhkANLjpnYYLs4lynb3R2blR39FSEVWr8AQ "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 bytes
```
UJḤ$¦
```
[Try it online!](https://tio.run/##y0rNyan8/z/U6@GOJSqHlv0/3H500sOdM/7/j1bySC1KVUgE4uL83FSFnMy81GIlHaX8NIWS1IoShbT8IoXK/FKgSEm@Qm5iNlApkJ2UX1pcUpRfkJGakp@nFAsA "Jelly – Try It Online")\*
*\*Jelly outputs nested lists joined by spaces, and there is no native string type. Strings in Jelly are lists of characters, and that's why they're displayed that way. If you want them to be merged by spaces, [Try this](https://tio.run/##y0rNyan8/z/U6@GOJSqHlv0/3O79/3@0kkdqUapCIhAX5@emKuRk5qUWK@ko5acplKRWlCik5RcpVOaXAkVK8hVyE7OBSoHspPzS4pKi/IKM1JT8PKVYAA).*
[Answer]
# [Retina](https://github.com/m-ender/retina), 18 bytes
```
{O$^`\G.
*2G`
2A`
```
[Try it online!](https://tio.run/##K0otycxL/P@/2l8lLiHGXY@LS8vIPYHLyDHh/3@P1KJUhUQgLs7PTVXIycxLLebKT1MoSa0oUUjLL1KozC/lKslXyE3MBirjSsovLS4pyi/ISE3JzwMA "Retina – Try It Online") Explanation: The first stage reverse the first line, then the second stage prints the first two lines, after which the third stage deletes them. The whole program then repeats until there is nothing left. One trailing newline could be removed at a cost of a leading `;`.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 33 bytes
```
Fold[StringReverse@*Append,{},#]&
```
[Try it online!](https://tio.run/##DYpBCsIwEEWvMkRwITlE3YhL0WXpIppfG2wyYTItSunZYxYf3nv86HRCdBpert4kJO3rhWffP7TJ@44VUtCdzjkjebvt9jAcK3W0mSsE5NoKR9AcEoqxhkdSfJVGFvrx0ooyRfdp18ZPXooK5wmek9mH@gc "Wolfram Language (Mathematica) – Try It Online")
## How it works
`StringReverse@*Append`, when given a list of strings and another string as input, adds the string to the end of the list and then reverses all of the strings.
`Fold`ing the input with respect to the above means we:
* Reverse the first line.
* Add the second line to the end and reverse both of them.
* Add the third line to the end and reverse all three.
* Add the fourth line to the end and reverse all four.
* And so on, until we run out of lines.
Each line gets reversed one time fewer than the previous line, so the lines alternate direction.
]