Verwandt, aber sehr unterschiedlich.

Ein Boustrophedon ist ein Text, bei dem jede andere Zeile mit umgekehrten Buchstaben umgedreht oder umgekehrt ist.

In dieser Herausforderung werden wir nur jede zweite Zeile umkehren, aber die tatsächlich verwendeten Zeichen intakt lassen. Sie können wählen, welche Zeilen umgekehrt werden sollen, solange es sich um jede andere handelt.

Sie können den Text in jedem geeigneten Format verwenden, solange Sie keine oder mehrere druckbare ASCII-Zeilen mit jeweils null oder mehr Zeichen unterstützen.

Beispiele:

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

⊢∘⌽\

Die Eingabe ist ein Vektor von Zeichenvektoren.

⌽ ist eine Funktion, die einen Vektor umkehrt (wenn ⌽ sie monadisch angewendet wird).

⊢is " dex " - eine Funktion, die das richtige Argument zurückgibt. Wenn komponiert (∘ mit einer anderen Funktion fzusammengesetzt ist, wird diese monadisch, was A ⊢∘f Bäquivalent zu A ⊢ (f B)und daher istf B .

\ist der Scan- Operator. g\A B C ...ist der VektorA (A g B) (A g (B g C)) ... bei dem gdyadisch angewendet wird (Infixnotation). Setzt man ⊢∘⌽für die ges vereinfacht zu:

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

Die Umkehrungen an geraden Positionen (oder ungeraden, je nachdem, wie Sie zählen) werden aufgehoben.

Probieren Sie es online!

Haskell , 26 Bytes

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

Probieren Sie es online! Anwendungsbeispiel:zipWith($)l ["abc","def","ghi"] Erträge ["abc","fed","ghi"].

Erläuterung:

l ist eine unendliche Liste von Funktionen, die zwischen dem id Entitätsfunktion und der reverseFunktion .

Die Hauptfunktion zippt lund die Eingabeliste mit der Funktionsanwendung $, dh für eine Eingabe, die ["abc", "def", "ghi"]wir erhalten [id$"abc", reverse$"def", id$"ghi"].

Schale , 4 Bytes

z*İ_

Nimmt eine Liste von Zeichenfolgen auf und gibt sie zurück (der Interpreter verbindet das Ergebnis vor dem Drucken implizit durch Zeilenumbrüche). Die erste Zeichenfolge ist umgekehrt. Probieren Sie es online!

Erläuterung

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

Wenn Sie in Husk eine Zeichenfolge mit einer Zahl multiplizieren, wird sie so oft wiederholt und umgekehrt, wenn die Zahl negativ ist.

JavaScript (ES6), Firefox, 43 Byte

Diese Version missbraucht den Sortieralgorithmus von Firefox . In Chrome wird Müll erzeugt, und die Zeichenfolgen in Edge werden überhaupt nicht geändert.

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

Testfälle

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

Oder versuchen Sie es online! (Spinnenaffe)

JavaScript (ES6), 45 Byte

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

Testfälle

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 Bytes

⌽¨@{2|⍳≢⍵}

Funktioniert in beide Richtungen:

Probieren Sie es online! mit⎕IO←1

Probieren Sie es online! mit⎕IO←0

Wie es funktioniert:

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

ungerade Zeilen vertauscht

$_=reverse if$.%2

gerade Zeilen vertauscht

$_=reverse if$|--

Nach dem Kommentar von @ Martin: Die Eingabe muss einen nachgestellten Zeilenumbruch haben.

versuche es online

Haskell , 27 Bytes

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

Probieren Sie es online!

Haskell , 30 Bytes

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

Probieren Sie es online!

Rekursion FTW.

05AB1E , 5 4 Bytes

εNFR

Probieren Sie es online!

Erläuterung

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

K (OK) , 17 14 Bytes

Lösung:

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

Probieren Sie es online!

Beispiel:

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

Erläuterung:

reverseAn ungeraden Indizes der Eingabeliste anwenden :

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

Anmerkungen:

• schaltet out &(#x)#0 1für &2!!#x3 Bytes speichern

APL (Dyalog) , 12 Bytes

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

Probieren Sie es online!

Python 2 , 40 36 Bytes

-4 Bytes dank @ Mr.Xcoder

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

Probieren Sie es online!

Ausgaben durch Ändern der Eingabeliste

Python 2 , 43 Bytes

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

Probieren Sie es online!

Alumin , 66 Bytes

hdqqkiddzhceyhhhhhdaeuzepkrlhcwdqkkrhzpkzerlhcwqopshhhhhdaosyhapzw

Probieren Sie es online!

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

  OUTPUT A NEWLINE
  hhhhhdao
syhapzw

J 9 Bytes

(,|.&.>)/

Reduzieren Sie von rechts nach links, indem Sie alle Zeichenfolgen im Ergebnis umkehren und die nächste Zeichenfolge wie sie ist voranstellen.

Probieren Sie es online!

Wir können 6 mit dem Ansatz von ngn machen , aber es wird zusätzliche Leerzeichen geben:

]&|./\

Probieren Sie es online!

R , 85 Bytes

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

Probieren Sie es online!

Eingabe von stdin und Ausgabe nach stdout.

Jede Zeile muss mit einem Zeilenvorschub / Wagenrücklauf / CRLF abgeschlossen werden und wird mit einer entsprechenden neuen Zeile gedruckt. Eingaben müssen also einen nachgestellten Zeilenvorschub haben.

Gelee , 5 4 Bytes

U¹ƭ€

Probieren Sie es online!

Danke HyperNeutrino für -1 Bytes! (Eigentlich, weil ich ƭaufgrund fehlender Dokumentation nie wusste, wie es funktioniert, diesmal hatte ich Glück)

T-SQL, 65 Bytes

Unsere Standardeingaberegeln ermöglichen es SQL, Werte aus einer bereits vorhandenen Tabelle einzugeben. Da SQL von Natur aus ungeordnet ist, muss die Tabelle Zeilennummern aufweisen, um die ursprüngliche Textreihenfolge beizubehalten.

Ich habe die Tabelle mit einer Identitätsspalte definiert, damit wir einfach Textzeilen nacheinander einfügen können (nicht auf die Gesamtsumme des Bytes angerechnet):

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

So wählen Sie abwechselnde Zeilen aus und kehren sie um:

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

Beachten Sie, dass ich 11 Bytes sparen kann, indem ich das ausschließe ORDER BY i, und dass die Liste wahrscheinlich in der ursprünglichen Reihenfolge für jede angemessene Länge zurückgegeben wird (dies gilt sicherlich für das 4-zeilige Beispiel). SQL garantiert dies jedoch nur , wenn Sie die ORDER BYeinbeziehen. Wenn wir also beispielsweise 10.000 Zeilen hätten, würden wir dies definitiv brauchen.

Perl 6 , 44 Bytes

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

Versuch es

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
}

Komma getrennt:

Stax , 12 Bytes

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

Führen Sie es aus und debuggen Sie es

Eingabe: ABC, def, GHI, jkl, MNO, pqr, STU

Newline begrenzt:

Stax , 8 Bytes

Çε÷┘)¼M@

Führen Sie es aus und debuggen Sie es

Eingang:

ABC
def
GHI
jkl
MNO
pqr
STU

Ausgabe für beide:

CBA
def
IHG
jkl
ONM
pqr
UTS

Eigentlich 7 Bytes

;r'R*♀ƒ

Erläuterung:

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

Probieren Sie es online!

Alice , 13 Bytes

M%/RM\
d&\tO/

Probieren Sie es online!

Eingabe über separate Befehlszeilenargumente. Kehrt die erste Zeile (und jede weitere Zeile danach) um.

Erläuterung

       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.

Standard-ML (MLton) , 51 Bytes

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

Probieren Sie es online! Anwendungsbeispiel:$ ["abc","def","ghi"] Erträge ["abc","fed","ghi"].

Erläuterung:

$ist eine Funktion, die sich über eine Liste von Zeichenfolgen wiederholt. Es dauert zwei Strings aund baus der Liste, hält die erste unverändert und kehrt die zweite durch die Zeichenfolge in eine Liste von Zeichen Transformation ( explode), die Umkehrung der Liste ( rev), und es zurück in einen String drehen ( implode).

Retina , 18 Bytes

{O$^`\G.

*2G`
2A`

Probieren Sie es online! Erläuterung: In der ersten Stufe wird die erste Zeile umgekehrt, in der zweiten Stufe werden die ersten beiden Zeilen gedruckt, und in der dritten Stufe werden sie gelöscht. Das ganze Programm wiederholt sich dann, bis nichts mehr übrig ist. Eine nachgestellte Zeile könnte zu Lasten eines Führenden entfernt werden ;.

Wolfram Language (Mathematica) , 33 Byte

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

Probieren Sie es online!

Wie es funktioniert

StringReverse@*AppendWenn eine Liste von Zeichenfolgen und eine andere Zeichenfolge als Eingabe angegeben werden, wird die Zeichenfolge am Ende der Liste hinzugefügt und anschließend alle Zeichenfolgen umgekehrt.

FoldDie Eingabe in Bezug auf das oben Gesagte bedeutet, dass wir:

• Kehre die erste Zeile um.
• Fügen Sie die zweite Zeile am Ende hinzu und kehren Sie beide um.
• Fügen Sie die dritte Zeile zum Ende hinzu und kehren Sie alle drei um.
• Fügen Sie die vierte Zeile zum Ende hinzu und kehren Sie alle vier um.
• Und so weiter, bis wir keine Linien mehr haben.

Jede Zeile wird um ein Mal weniger als die vorherige Zeile umgekehrt, sodass die Zeilen die Richtung wechseln.

CJam , 11 Bytes

{2/Waf.%:~}

Probieren Sie es online! (CJam-Array-Literale verwenden Leerzeichen, um Elemente zu trennen.)

Erläuterung:

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

Erklärung für den Teil Waf.%"Schwarze Magie":

• Wist eine Variable, für die vorinitialisiert wurde -1. abricht ein Element in ein Array ein, so Waist es [-1].
• %Knallt eine Zahl nund ein Array aund nimmt jedes nElement des Arrays. Wenn nes negativ ist, wird es auch umgekehrt, was bedeutet, dass W%ein Array umgekehrt wird.
• . gefolgt von einer binären Operation wendet diese Operation auf entsprechende Elemente eines Arrays an [1 2 3] [4 5 6] .+ ist [5 7 9]. Wenn ein Array länger als das andere ist, bleiben die Elemente unverändert, was bedeutet, dass Wa.%das erste Element eines Arrays umgekehrt wird.
• fgefolgt von einer binären Operation wird ein Element aus dem Stapel genommen und verhält sich dann so {<that element> <that operation>}%, als würde man jedes Element im Array durchgehen, sein Element verschieben, das Element zuerst aus dem Stapel verschieben, die Operation ausführen und dann die Ergebnisse sammeln zurück in ein Array. Dies bedeutet, dass Wa.f%das erste Element jedes Elements im Array umgekehrt wird.

V , 4 Bytes

òjæ$

Probieren Sie es 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$

Swift , 90 85 82 72 Bytes

-10 Bytes dank @ Mr.Xcoder

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

Rubin , 19 + 2 = 21 Bytes

+2 Bytes für -nlFlags.

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

Probieren Sie es online!

Erläuterung

Praktisch identisch mit der Perl 5-Antwort , obwohl ich diese nicht gesehen hatte, als ich sie schrieb.

Mit Leerzeichen sieht der Code folgendermaßen aus:

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

Die -pOption bewirkt, dass Ruby Ihr Skript effektiv in eine Schleife einfügt:

while gets
  # ...
  puts $_
end

Die Sondervariable $_enthält die zuletzt gelesene Zeile getsund $.die Zeilennummer.

Die -lermöglicht eine automatische Linie Verarbeitung beendet wird , die automatisch Anrufe chop!an jeder Eingangsleitung, die das das entfernt , \nbevor wir es umgekehrt.

GNU sed , 31 + 1 = 32 Bytes

+1 Byte für -rFlag.

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

Probieren Sie es online!

Erläuterung

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

Kohle , 9 Bytes

ＥＮ⎇﹪ι²⮌ＳＳ

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Hinweis: Da Charcoal die Länge der Liste nicht kennt, habe ich sie als zusätzliches Element hinzugefügt. Erläuterung:

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

Probieren Sie es online

Gibt die erste Zeile in umgekehrter Reihenfolge aus. Hat einen nachgestellten Zeilenumbruch.

Grundsätzlich wird zwischen dem Drucken bei der Eingabe und dem Speichern der Eingabe auf dem Stapel gewechselt. Wenn es eine neue Zeile oder das Ende der Eingabe erreicht, druckt es den Stapel aus, druckt eine neue Zeile und ändert das Zeichen bei 0,4 so, dass es entweder ein # oder ein No-Op ist, um den Modus zu ändern. Wenn es das Ende der Eingabe war, beenden Sie das Programm