相关但非常不同。

一个牛耕式转行书写法就是写作的所有其他行翻转或反转，并反转字母文本。

在此挑战中，我们将每隔一行反转一次，而使实际使用的字符保持不变。您可以选择要反转的行，只要它们彼此间隔即可。

只要您支持零行或更多行的可打印ASCII行（每行包含零个或多个字符），就可以采用任何合适的格式的文本。

例子：

["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"]

APL（Dyalog Classic），4字节

⊢∘⌽\

输入是字符向量的向量。

⌽是反转向量的功能（单次⌽应用时）。

⊢是“ dex ”-返回其正确参数的函数。当（∘）与另一个函数组成时，f它迫使后者是单数的，A ⊢∘f B等于A ⊢ (f B)和因此f B。

\是扫描运算符。g\A B C ...是向量A (A g B) (A g (B g C)) ...，其中g被施加dyadically（缀表示法）。替换⊢∘⌽为g它简化为：

A (A ⊢∘⌽ B) (A ⊢∘⌽ (B ⊢∘⌽ C)) ...
A (⌽B) (⌽⌽C) ....
A (⌽B) C ....

偶数位置（或奇数，取决于您的计数方式）的冲销抵消。

在线尝试！

Haskell，26个字节

zipWith($)l
l=id:reverse:l

在线尝试！用法示例：zipWith($)l ["abc","def","ghi"]yields ["abc","fed","ghi"]。

说明：

l是在id实体功能和reverse功能之间交替的功能的无限列表。

主要函数zip l和函数应用程序的输入列表$，即["abc", "def", "ghi"]我们得到的输入[id$"abc", reverse$"def", id$"ghi"]。

外壳，4个字节

z*İ_

获取并返回一个字符串列表（解释器在打印之前通过换行符隐式地将结果连接起来）。第一个字符串反转。 在线尝试！

说明

z*İ_  Implicit input.
  İ_  The infinite list [-1,1,-1,1,-1,1..
z     Zip with input
 *    using multiplication.

在Husk中，将字符串与数字相乘会重复多次，如果数字为负，也会将其反转。

JavaScript（ES6），Firefox，43字节

此版本滥用Firefox的排序算法。它会在Chrome上产生垃圾，并且根本不会更改Edge上的字符串。

a=>a.map((s,i)=>[...s].sort(_=>i&1).join``)

测试用例

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([]))

或在线尝试！（蜘蛛猴）

JavaScript（ES6），45个字节

a=>a.map(s=>(a^=1)?s:[...s].reverse().join``)

测试用例

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([]))

APL（Dyalog Unicode），10字节

⌽¨@{2|⍳≢⍵}

双向工作：

在线尝试！与⎕IO←1

在线尝试！与⎕IO←0

怎么运行的：

⌽¨@{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

Perl 5、17 + 2（-pl）= 19个字节

奇数行反转

$_=reverse if$.%2

偶数行反转

$_=reverse if$|--

@Martin发表评论之后：输入内容必须带有换行符。

在线尝试

Haskell，27个字节

foldr((.map reverse).(:))[]

在线尝试！

Haskell，30个字节

f(a:b:c)=a:reverse b:f c
f a=a

在线尝试！

递归FTW。

05AB1E，5 4字节

εNFR

在线尝试！

说明

ε     # apply to each element (row)
 NF   # index times do:
   R  # reverse

K（oK），17 14字节

解：

@[;&2!!#x;|]x:

在线尝试！

例：

@[;&2!!#x;|]x:("this is";"my example";"of the";"solution")
("this is"
"elpmaxe ym"
"of the"
"noitulos")

说明：

适用reverse于输入列表的奇数索引：

@[;&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

笔记：

• 切换出&(#x)#0 1用于&2!!#x保存3个字节

APL（Dyalog），12字节

⍳∘≢{⌽⍣⍺⊢⍵}¨⊢

在线尝试！

Python 2中，40 36个字节

-4个字节，感谢@ Mr.Xcoder

def f(k):k[::2]=map(reversed,k[::2])

在线尝试！

通过修改输入列表进行输出

Python 2，43个字节

f=lambda k,d=1:k and[k[0][::d]]+f(k[1:],-d)

在线尝试！

铝，66字节

hdqqkiddzhceyhhhhhdaeuzepkrlhcwdqkkrhzpkzerlhcwqopshhhhhdaosyhapzw

在线尝试！

FLAG: h
hq
  CONSUME A LINE
  qk
  iddzhceyhhhhhdaeuze
  pk
  rlhcw
  REVERSE STACK CONDITIONALLY
  dqkkrhzpkzerlhcwqops

  OUTPUT A NEWLINE
  hhhhhdao
syhapzw

J，9个字节

(,|.&.>)/

从右向左减少，反转结果中的所有字符串，并按原样添加下一个字符串。

在线尝试！

我们可以使用ngn的方法来做6，但是会有额外的空间：

]&|./\

在线尝试！

R，85字节

for(i in seq(l<-strsplit(readLines(),"")))cat("if"(i%%2,`(`,rev)(l[[i]]),"\n",sep="")

在线尝试！

从stdin输入，然后输出到stdout。

每行必须以换行符/回车符/ CRLF终止，并以相应的换行符打印。因此，输入必须具有尾随换行符。

果冻，5 4字节

U¹ƭ€

在线尝试！

感谢HyperNeutrino -1个字节！（实际上是因为ƭ缺乏文档我不知道如何工作，这次我很幸运）

T-SQL，65个字节

我们的标准输入规则允许SQL 从预先存在的表中输入值，并且由于SQL本质上是无序的，因此表必须具有行号以保留原始文本顺序。

我用一个标识列定义了表，所以我们可以简单地按顺序插入文本行（不计入字节总数）：

CREATE TABLE t 
    (i int identity(1,1)
    ,a varchar(999))

因此要选择并反转交替的行：

SELECT CASE WHEN i%2=0THEN a
ELSE reverse(a)END
FROM t
ORDER BY i

请注意，我可以通过排除来节省11个字节ORDER BY i，并且很可能以任何合理的长度以原始顺序返回列表（对于4行示例确实如此）。但是SQL仅在包含时才保证它ORDER BY，因此，如果我们有10,000行，我们肯定会需要它。

Perl 6，44个字节

lines.map: ->\a,$b?{a.put;.flip.put with $b}

试试吧

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
}

以逗号分隔：

Stax，12 个字节

ü«äì╠▒╕█╬pεû

运行并调试

输入：ABC，def，GHI，jkl，MNO，pqr，STU

换行符分隔：

Stax，8 个字节

Çε÷┘)¼M@

运行并调试

输入：

ABC
def
GHI
jkl
MNO
pqr
STU

两者的输出：

CBA
def
IHG
jkl
ONM
pqr
UTS

实际上，7个字节

;r'R*♀ƒ

说明：

;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)

在线尝试！

爱丽丝，13字节

M%/RM\
d&\tO/

在线尝试！

通过单独的命令行参数输入。反转第一行（以及此后的所有其他行）。

说明

       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.

标准ML（MLton），51字节

fun$(a::b::r)=a::implode(rev(explode b)):: $r| $e=e

在线尝试！用法示例：$ ["abc","def","ghi"]yields ["abc","fed","ghi"]。

说明：

$是在字符串列表中递归的函数。这需要两个字符串a，并b从列表中，保持第一不变，反转第二个通过转换成字符串的字符列表（explode），倒车名单（rev），并把它放回一个字符串（implode）。

视网膜，18字节

{O$^`\G.

*2G`
2A`

在线尝试！说明：第一阶段反转第一行，然后第二阶段打印前两行，然后第三阶段删除它们。然后重复整个程序，直到剩下一无所有。一条尾随的换行符可能会被删除，而前导的代价是;。

Wolfram语言（Mathematica），33个字节

Fold[StringReverse@*Append,{},#]&

在线尝试！

怎么运行的

StringReverse@*Append，当给定一个字符串列表和另一个字符串作为输入时，将字符串添加到列表的末尾，然后反转所有字符串。

Fold关于上述内容的输入意味着我们：

• 反转第一行。
• 将第二行添加到末尾，然后将它们都反向。
• 在第三行末尾添加第三行。
• 将第四行添加到末尾，然后将全部四行反向。
• 依此类推，直到我们用完为止。

每行反转的次数比前一行少一倍，因此各行交替显示方向。

CJam，11个字节

{2/Waf.%:~}

在线尝试！（CJam数组文字使用空格分隔元素）

说明：

{              Begin block, stack: ["Here are some lines" "of text for you" "to make a" "boustrophedon"]
 2/            Group by 2:         [["Here are some lines" "of text for you"] ["to make a" "boustrophedon"]]
   W           Push -1:            [["Here are some lines" "of text for you"] ["to make a" "boustrophedon"]] -1
    a          Wrap in array:      [["Here are some lines" "of text for you"] ["to make a" "boustrophedon"]] [-1]
     f.%       Vectorized zipped array reverse (black magic):
                                   [["senil emos era ereH" "of text for you"] ["a ekam ot" "boustrophedon"]]
        :~     Flatten:            ["senil emos era ereH" "of text for you" "a ekam ot" "boustrophedon"]
          }

解释为Waf.%“黑魔法”的一部分：

• W是预先初始化为的变量-1。a包装在一个数组中的元素，所以Wa是[-1]。
• %弹出一个数字n和一个数组，a并获取数组的每个n元素。当n为负数时，它也会反转它，这意味着W%反转数组。
• .随后的二进制操作适用该操作相对应的阵列的元件，所以[1 2 3] [4 5 6] .+是[5 7 9]。如果一个数组比另一个数组长，则保留这些元素而不进行修改，这意味着将Wa.%反转数组的第一个元素。
• f然后执行二进制操作将从堆栈中取出一个元素，然后像进行操作{<that element> <that operation>}%，即遍历数组中的每个元素，推入其元素，推入首先从堆栈中弹出的元素，运行操作，然后收集结果返回数组。这意味着将Wa.f%反转数组中每个元素的第一个元素。

V，4个字节

òjæ$

在线尝试！

ò      ' <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$

迅捷，90 85 82 72字节

-10个字节，感谢@ Mr.Xcoder

func f(a:[String]){print(a.reduce([]){$0.map{"\($0.reversed())"}+‌​[$1]})}

红宝石，19 + 2 = 21字节

+2个字节用于-nl标志。

$.%2<1&&$_.reverse!

在线尝试！

说明

几乎与Perl 5的答案相同，尽管在撰写本文时我还没有看到答案。

使用空格，代码如下所示：

$. % 2 < 1 && $_.reverse!

该-p选项使Ruby可以有效地将脚本包装在这样的循环中：

while gets
  # ...
  puts $_
end

特殊变量$_包含读取的最后一行gets，并$.包含行号。

在-l使结束处理自动线，自动呼叫chop!上每个输入线路，从而消除了在\n我们扭转之前。

GNU sed，31 + 1 = 32字节

+1字节的-r标志。

G
:
s/(.)(.*\n)/\2\1/
t
s/.//
N

在线尝试！

说明

G                   # Append a newline and contents of the (empty) hold space
:
  s/(.)(.*\n)/\2\1/   # Move the first character to after the newline
  t                   # If we made the above substitution, branch to :
s/.//               # Delete the first character (now the newline)
N                   # Append a newline and the next line of input

木炭，9字节

ＥＮ⎇﹪ι²⮌ＳＳ

在线尝试！链接是详细版本的代码。注意：木炭不知道列表的长度，因此我将其添加为额外元素。说明：

 Ｎ          First value as a number
Ｅ           Map over implicit range
    ι       Current index
     ²      Literal 2
   ﹪        Modulo
  ⎇         Ternary
       Ｓ    Next string value
      ⮌     Reverse
        Ｓ   Next string value
            Implicitly print array, one element per line.

Befunge-93，48个字节

 <~,#_|#*-+92:+1:
#^_@  >:#,_"#"40g!*40p91+,~:1+

在线试用

反向打印第一行。尾随换行符。

基本上，它通过在获取输入时进行打印与将输入存储在堆栈上之间交替工作。当到达换行符或输入结尾时，它会打印出堆栈，打印换行符，然后将0,4处的字符修改为＃或无操作符以更改模式。如果输入结束，则结束程序