ที่เกี่ยวข้อง แต่แตกต่างกันมาก

boustrophedonคือข้อความที่ทุกสายอื่น ๆ ของการเขียนจะพลิกหรือกลับด้วยตัวอักษรกลับรายการ

ในความท้าทายนี้เราจะย้อนกลับบรรทัดอื่นทุกบรรทัด แต่ปล่อยให้ตัวละครที่แท้จริงใช้เหมือนเดิม คุณอาจเลือกบรรทัดที่จะย้อนกลับตราบใดที่มันเป็นเส้นอื่น

คุณสามารถนำข้อความในรูปแบบที่เหมาะสมตราบใดที่คุณสนับสนุนศูนย์ 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 ไบต์

⊢∘⌽\

อินพุตเป็นเวกเตอร์ของอักขระเวกเตอร์

⌽เป็นฟังก์ชั่นที่กลับเวกเตอร์ (เมื่อ⌽ใช้แบบ monadically)

⊢คือ " 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"]["abc","fed","ghi"]

คำอธิบาย:

lเป็นรายการที่ไม่มีที่สิ้นสุดของฟังก์ชั่นสลับระหว่างidฟังก์ชั่นเอนทิตี้และreverseฟังก์ชั่น

ซิปฟังก์ชั่นหลักlและรายชื่อการป้อนข้อมูลที่มีการประยุกต์ใช้ฟังก์ชั่น$ที่เป็นสำหรับการป้อนข้อมูลที่เราได้รับ["abc", "def", "ghi"][id$"abc", reverse$"def", id$"ghi"]

Husk , 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)

ลองออนไลน์!

Alumin , 66 ไบต์

hdqqkiddzhceyhhhhhdaeuzepkrlhcwdqkkrhzpkzerlhcwqopshhhhhdaosyhapzw

ลองออนไลน์!

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

  OUTPUT A NEWLINE
  hhhhhdao
syhapzw

J , 9 ไบต์

(,|.&.>)/

ลดจากขวาไปซ้ายย้อนกลับสตริงทั้งหมดในผลลัพธ์และเตรียมสตริงถัดไปตามที่เป็นอยู่

ลองออนไลน์!

เราสามารถทำ6โดยใช้วิธีของ ngnแต่จะมีช่องว่างเพิ่มเติม:

]&|./\

ลองออนไลน์!

R , 85 ไบต์

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

ลองออนไลน์!

อินพุตจาก stdin และเอาต์พุตไปยัง stdout

แต่ละบรรทัดต้องถูกยกเลิกโดย linefeed / carriage return / CRLF และพิมพ์ด้วยบรรทัดใหม่ที่เกี่ยวข้อง ดังนั้นอินพุตจำเป็นต้องมี linefeed ต่อท้าย

เยลลี่ , 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"]["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เริ่มต้นเป็น awraps องค์ประกอบในอาร์เรย์จึงเป็น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$

Swift , 90 85 82 72 ไบต์

-10 ไบต์ขอบคุณ @ @ Mr.Xcoder

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

Ruby , 19 + 2 = 21 ไบต์

+2 ไบต์สำหรับ-nlแฟล็ก

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

ลองออนไลน์!

คำอธิบาย

เหมือนกันกับคำตอบ Perl 5แม้ว่าฉันจะไม่ได้เห็นอย่างใดอย่างหนึ่งเมื่อฉันเขียนนี้

ด้วยช่องว่างโค้ดมีลักษณะดังนี้:

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

-pตัวเลือกที่ทำให้ทับทิมได้อย่างมีประสิทธิภาพห่อสคริปต์ของคุณในวงเช่นนี้:

while gets
  # ...
  puts $_
end

ตัวแปรพิเศษ$_ประกอบด้วยบรรทัดสุดท้ายที่อ่านโดยgetsและ$.มีหมายเลขบรรทัด

การ-lเปิดใช้งานการสิ้นสุดบรรทัดอัตโนมัติซึ่งจะเรียกใช้chop!กับแต่ละบรรทัดอินพุตโดยอัตโนมัติซึ่งจะลบสิ่ง\nที่เราทำก่อนที่เราจะย้อนกลับ

รุ่น GNU , 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 bytes

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

ลองใช้ออนไลน์

พิมพ์บรรทัดแรกในสิ่งที่ตรงกันข้าม มีการขึ้นบรรทัดใหม่

โดยทั่วไปจะทำงานโดยสลับระหว่างการพิมพ์เมื่อได้รับอินพุตและจัดเก็บอินพุตบนสแต็ก เมื่อมาถึงบรรทัดใหม่หรือสิ้นสุดอินพุตมันจะพิมพ์สแต็กพิมพ์บรรทัดใหม่และแก้ไขอักขระที่ 0,4 ให้เป็น # หรือ no-op เพื่อเปลี่ยนโหมด หากเป็นส่วนท้ายของอินพุตให้จบโปรแกรม