Liên quan nhưng rất khác nhau.

Một boustrophedon là một văn bản mà mỗi dòng khác của văn bản là lộn hoặc đảo ngược, với chữ đảo ngược.

Trong thử thách này, chúng tôi sẽ chỉ đảo ngược mọi dòng khác, nhưng giữ nguyên các ký tự thực tế được sử dụng. Bạn có thể chọn dòng nào để đảo ngược, miễn là nó là dòng khác.

Bạn có thể lấy văn bản ở bất kỳ định dạng phù hợp nào miễn là bạn hỗ trợ 0 hoặc nhiều dòng ASCII có thể in được, mỗi dòng có 0 hoặc nhiều ký tự.

Ví dụ:

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

⊢∘⌽\

Đầu vào là một vectơ của vectơ ký tự.

⌽là một hàm đảo ngược một vectơ (khi ⌽được áp dụng một cách đơn điệu).

⊢là " dex " - một hàm trả về đúng đối số của nó. Khi hợp thành ( ∘) với một chức năng khác, fnó buộc cái sau phải là đơn âm A ⊢∘f Btương đương A ⊢ (f B)và do đó f B.

\là toán tử quét . g\A B C ...là vectơ A (A g B) (A g (B g C)) ...nơi gđược áp dụng dyadally (ký hiệu infix). Thay thế ⊢∘⌽cho gnó đơn giản hóa để:

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

Việc đảo ngược tại các vị trí chẵn (hoặc lẻ, tùy thuộc vào cách bạn đếm) hủy bỏ.

Hãy thử trực tuyến!

Haskell , 26 byte

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

Hãy thử trực tuyến! Ví dụ sử dụng: zipWith($)l ["abc","def","ghi"]sản lượng ["abc","fed","ghi"].

Giải trình:

llà một danh sách vô hạn các hàm xen kẽ giữa idhàm thực thể và reversehàm.

Các chức năng chính khóa lvà danh sách đầu vào với ứng dụng chức năng $, đó là cho một đầu vào ["abc", "def", "ghi"]chúng ta nhận được [id$"abc", reverse$"def", id$"ghi"].

Husk , 4 byte

z*İ_

Lấy và trả về một danh sách các chuỗi (trình thông dịch ngầm tham gia kết quả bằng các dòng mới trước khi in). Chuỗi đầu tiên được đảo ngược. Hãy thử trực tuyến!

Giải trình

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

Trong Husk, nhân một chuỗi với một số lặp lại nhiều lần, cũng đảo ngược nó nếu số đó âm.

JavaScript (ES6), Firefox, 43 byte

Phiên bản này lạm dụng thuật toán sắp xếp của Firefox . Nó tạo ra rác trên Chrome và hoàn toàn không thay đổi chuỗi trên Edge.

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

Các trường hợp thử nghiệm

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

Hoặc dùng thử trực tuyến! (Khỉ nhện)

JavaScript (ES6), 45 byte

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

Các trường hợp thử nghiệm

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 byte

⌽¨@{2|⍳≢⍵}

Hoạt động cả hai cách:

Hãy thử trực tuyến! với⎕IO←1

Hãy thử trực tuyến! với⎕IO←0

Làm thế nào nó hoạt động:

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

dòng lẻ đảo ngược

$_=reverse if$.%2

dòng chẵn đảo ngược

$_=reverse if$|--

Sau nhận xét của @ Martin: đầu vào cần phải có một dòng cấp dữ liệu.

thử trực tuyến

Haskell , 27 byte

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

Hãy thử trực tuyến!

Haskell , 30 byte

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

Hãy thử trực tuyến!

Đệ quy FTW.

05AB1E , 5 4 byte

εNFR

Hãy thử trực tuyến!

Giải trình

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

K (oK) , 17 14 byte

Dung dịch:

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

Hãy thử trực tuyến!

Thí dụ:

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

Giải trình:

Áp dụng reversetại các chỉ số lẻ của danh sách đầu vào:

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

Ghi chú:

• chuyển ra &(#x)#0 1cho &2!!#xtiết kiệm 3 byte

APL (Dyalog) , 12 byte

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

Hãy thử trực tuyến!

Python 2 , 40 36 byte

-4 byte nhờ @ Mr.Xcoder

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

Hãy thử trực tuyến!

Đầu ra bằng cách sửa đổi danh sách đầu vào

Python 2 , 43 byte

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

Hãy thử trực tuyến!

Alumin , 66 byte

hdqqkiddzhceyhhhhhdaeuzepkrlhcwdqkkrhzpkzerlhcwqopshhhhhdaosyhapzw

Hãy thử trực tuyến!

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

  OUTPUT A NEWLINE
  hhhhhdao
syhapzw

J , 9 byte

(,|.&.>)/

Giảm từ phải sang trái, đảo ngược tất cả các chuỗi trong kết quả và chuẩn bị trước chuỗi tiếp theo.

Hãy thử trực tuyến!

Chúng tôi có thể thực hiện 6 bằng cách sử dụng phương pháp của ngn , nhưng sẽ có thêm khoảng trắng:

]&|./\

Hãy thử trực tuyến!

R , 85 byte

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

Hãy thử trực tuyến!

Đầu vào từ stdin và đầu ra đến thiết bị xuất chuẩn.

Mỗi dòng phải được chấm dứt bởi một dòng cấp / trả lại vận chuyển / CRLF và nó được in với một dòng mới tương ứng. Vì vậy, đầu vào cần phải có một nguồn cấp dữ liệu.

Thạch , 5 4 byte

U¹ƭ€

Hãy thử trực tuyến!

Cảm ơn HyperNeutrino cho -1 byte! (thực ra vì tôi không bao giờ biết cách ƭhoạt động do thiếu tài liệu, lần này tôi đã gặp may)

T-SQL, 65 byte

Các quy tắc đầu vào tiêu chuẩn của chúng tôi cho phép SQL nhập các giá trị từ một bảng có sẵn và do SQL vốn không có thứ tự, nên bảng phải có số hàng để giữ trật tự văn bản gốc.

Tôi đã xác định bảng với một cột định danh để chúng tôi có thể chỉ cần chèn các dòng văn bản một cách tuần tự (không được tính vào tổng byte):

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

Vì vậy, để chọn và đảo ngược các hàng xen kẽ:

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

Lưu ý rằng tôi có thể lưu 11 byte bằng cách loại trừ ORDER BY ivà có khả năng trả về danh sách theo thứ tự ban đầu cho bất kỳ độ dài hợp lý nào (chắc chắn là như vậy đối với ví dụ 4 dòng). Nhưng SQL chỉ đảm bảo nó nếu bạn bao gồm ORDER BY, vì vậy nếu chúng ta có 10.000 hàng, chúng tôi chắc chắn sẽ cần điều này.

Perl 6 , 44 byte

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

Thử nó

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
}

Dấu phẩy được phân cách:

Stax , 12 byte

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

Chạy và gỡ lỗi nó

đầu vào: ABC, def, GHI, jkl, MNO, pqr, STU

Phân định dòng mới:

Stax , 8 byte

Çε÷┘)¼M@

Chạy và gỡ lỗi nó

đầu vào:

ABC
def
GHI
jkl
MNO
pqr
STU

đầu ra cho cả hai:

CBA
def
IHG
jkl
ONM
pqr
UTS

Trên thực tế , 7 byte

;r'R*♀ƒ

Giải trình:

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

Hãy thử trực tuyến!

Alice , 13 byte

M%/RM\
d&\tO/

Hãy thử trực tuyến!

Nhập thông qua các đối số dòng lệnh riêng biệt. Đảo ngược dòng đầu tiên (và mọi dòng khác sau đó).

Giải trình

       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 chuẩn (MLton) , 51 byte

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

Hãy thử trực tuyến! Ví dụ sử dụng: $ ["abc","def","ghi"]sản lượng ["abc","fed","ghi"].

Giải trình:

$là một hàm đệ quy trên một danh sách các chuỗi. Nó lấy hai chuỗi avà btừ danh sách, giữ cho chuỗi đầu tiên không thay đổi và đảo ngược chuỗi thứ hai bằng cách chuyển đổi chuỗi thành danh sách các ký tự ( explode), đảo ngược danh sách ( rev) và biến nó trở lại thành chuỗi ( implode).

Võng mạc , 18 byte

{O$^`\G.

*2G`
2A`

Hãy thử trực tuyến! Giải thích: Giai đoạn đầu tiên đảo ngược dòng đầu tiên, sau đó giai đoạn thứ hai in hai dòng đầu tiên, sau đó giai đoạn thứ ba xóa chúng. Toàn bộ chương trình sau đó lặp lại cho đến khi không còn gì. Một dòng mới có thể được gỡ bỏ với chi phí hàng đầu ;.

Ngôn ngữ Wolfram (Mathicala) , 33 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

StringReverse@*Append, khi được cung cấp một danh sách các chuỗi và một chuỗi khác làm đầu vào, thêm chuỗi vào cuối danh sách và sau đó đảo ngược tất cả các chuỗi.

Folding đầu vào đối với các phương tiện trên có nghĩa là chúng tôi:

• Đảo ngược dòng đầu tiên.
• Thêm dòng thứ hai vào cuối và đảo ngược cả hai.
• Thêm dòng thứ ba vào cuối và đảo ngược cả ba.
• Thêm dòng thứ tư vào cuối và đảo ngược tất cả bốn.
• Và như vậy, cho đến khi chúng tôi hết dòng.

Mỗi dòng được đảo ngược ít hơn một lần so với dòng trước, vì vậy các dòng thay thế theo hướng.

CJam , 11 byte

{2/Waf.%:~}

Hãy thử trực tuyến! (Các mảng chữ của CJam sử dụng khoảng trắng để phân tách các phần tử)

Giải trình:

{              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"]
          }

Giải thích cho phần Waf.%"ma thuật đen":

• Wlà một biến được preinitialized thành -1. akết thúc tốt đẹp một phần tử trong một mảng, vì vậy Walà [-1].
• %bật một số nvà một mảng avà lấy mọi nphần tử thứ của mảng. Khi nlà âm, nó cũng đảo ngược nó, có nghĩa là W%đảo ngược một mảng.
• .theo sau là một phép toán hai ngôi áp dụng mà hoạt động đến các yếu tố của một mảng tương ứng, vì vậy [1 2 3] [4 5 6] .+là [5 7 9]. Nếu một mảng dài hơn mảng kia, các phần tử được giữ mà không sửa đổi, nghĩa là Wa.%đảo ngược phần tử đầu tiên của một mảng.
• ftheo sau là một hoạt động nhị phân sẽ lấy một phần tử từ ngăn xếp và sau đó hành động như thế {<that element> <that operation>}%, đi qua từng phần tử trong mảng, đẩy phần tử của nó, đẩy phần tử đầu tiên xuất hiện từ ngăn xếp, chạy hoạt động và sau đó thu thập kết quả trở lại thành một mảng. Điều này có nghĩa là Wa.f%đảo ngược phần tử đầu tiên của mọi phần tử trong mảng.

V , 4 byte

òjæ$

Hãy thử trực tuyến!

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

Swift , 90 85 82 72 byte

-10 byte nhờ @ Mr.Xcoder

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

Ruby , 19 + 2 = 21 byte

+2 byte cho -nlcờ.

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

Hãy thử trực tuyến!

Giải trình

Thực tế giống hệt với câu trả lời Perl 5 , mặc dù tôi đã không thấy câu trả lời đó khi tôi viết bài này.

Với khoảng trắng, mã trông như thế này:

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

Các -ptùy chọn làm cho hiệu quả của Ruby quấn kịch bản của bạn trong một vòng lặp như thế này:

while gets
  # ...
  puts $_
end

Biến đặc biệt $_chứa dòng cuối cùng được đọc bởi getsvà $.chứa số dòng.

Việc -lcho phép xử lý kết thúc dòng tự động, tự động gọi chop!trên mỗi dòng đầu vào, loại bỏ dòng \ntrước khi chúng tôi đảo ngược nó.

GNU sed , 31 + 1 = 32 byte

+1 byte cho -rcờ.

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

Hãy thử trực tuyến!

Giải trình

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

Than , 9 byte

ＥＮ⎇﹪ι²⮌ＳＳ

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Lưu ý: Than không biết độ dài của danh sách, vì vậy tôi đã thêm nó dưới dạng một yếu tố phụ. Giải trình:

 Ｎ          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 byte

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

Dùng thử trực tuyến

In dòng đầu tiên ngược lại. Có một dòng mới.

Về cơ bản, nó hoạt động bằng cách xen kẽ giữa việc in khi nhận được đầu vào và lưu trữ đầu vào trên ngăn xếp. Khi đạt đến một dòng mới hoặc kết thúc đầu vào, nó sẽ in ra ngăn xếp, in một dòng mới và sửa đổi ký tự ở 0,4 thành # hoặc không thay đổi chế độ. Nếu đó là kết thúc của đầu vào, kết thúc chương trình