Correlato ma molto diverso.

Un boustrophedon è un testo in cui ogni altra riga della scrittura è capovolta o invertita, con lettere invertite.

In questa sfida, invertiremo tutte le altre righe, ma lasceremo intatti i personaggi utilizzati. Puoi scegliere quali linee invertire, purché siano tutte le altre.

Puoi prendere il testo in qualsiasi formato adatto purché supporti zero o più righe di ASCII stampabile, ognuna con zero o più caratteri.

Esempi:

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

⊢∘⌽\

L'input è un vettore di vettori di caratteri.

⌽è una funzione che inverte un vettore (quando ⌽viene applicata monadico).

⊢è " dex " - una funzione che restituisce il suo argomento giusto. Quando composto ( ∘) con un'altra funzione fcostringe quest'ultimo a essere monadico come A ⊢∘f Bè equivalente A ⊢ (f B)e quindi f B.

\è l' operatore di scansione . g\A B C ...è il vettore in A (A g B) (A g (B g C)) ...cui gviene applicato diadicamente (notazione infissa). Sostituendo ⊢∘⌽per gsemplifica a:

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

Le inversioni in posizioni pari (o dispari, a seconda di come si conta) si annullano.

Provalo online!

Haskell , 26 byte

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

Provalo online! Esempio di utilizzo: zipWith($)l ["abc","def","ghi"]rese ["abc","fed","ghi"].

Spiegazione:

lè un elenco infinito di funzioni che si alternano tra la idfunzione entità e la reversefunzione.

La funzione principale si comprime le l'elenco di input con l'applicazione di funzione $, ovvero per un input ["abc", "def", "ghi"]che otteniamo [id$"abc", reverse$"def", id$"ghi"].

Buccia , 4 byte

z*İ_

Prende e restituisce un elenco di stringhe (l'interprete si unisce implicitamente al risultato con le nuove righe prima della stampa). La prima stringa è invertita. Provalo online!

Spiegazione

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

In Husk, moltiplicare una stringa con un numero lo ripete più volte, anche invertendolo se il numero è negativo.

JavaScript (ES6), Firefox, 43 byte

Questa versione abusa dell'algoritmo di ordinamento di Firefox . Genera spazzatura su Chrome e non altera affatto le stringhe su Edge.

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

Casi test

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

Oppure provalo online! (Ragno scimmia)

JavaScript (ES6), 45 byte

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

Casi test

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|⍳≢⍵}

Funziona in entrambi i modi:

Provalo online! con⎕IO←1

Provalo online! con⎕IO←0

Come funziona:

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

linee dispari invertite

$_=reverse if$.%2

linee pari invertite

$_=reverse if$|--

Dopo il commento di @ Martin: l'input deve avere un avanzamento riga finale.

provalo online

Haskell , 27 byte

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

Provalo online!

Haskell , 30 byte

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

Provalo online!

Ricorsione FTW.

05AB1E , 5 4 byte

εNFR

Provalo online!

Spiegazione

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

K (oK) , 17 14 byte

Soluzione:

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

Provalo online!

Esempio:

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

Spiegazione:

Applica reverseagli indici dispari dell'elenco di input:

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

Gli appunti:

• disattivato &(#x)#0 1per &2!!#xsalvare 3 byte

APL (Dyalog) , 12 byte

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

Provalo online!

Python 2 , 40 36 byte

-4 byte grazie a @ Mr.Xcoder

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

Provalo online!

Emette modificando l'elenco di input

Python 2 , 43 byte

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

Provalo online!

Allumina , 66 byte

hdqqkiddzhceyhhhhhdaeuzepkrlhcwdqkkrhzpkzerlhcwqopshhhhhdaosyhapzw

Provalo online!

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

  OUTPUT A NEWLINE
  hhhhhdao
syhapzw

J , 9 byte

(,|.&.>)/

Riduci da destra a sinistra, invertendo tutte le stringhe nel risultato e anteponendo la stringa successiva così com'è.

Provalo online!

Possiamo fare 6 usando l'approccio di ngn , ma ci saranno spazi extra:

]&|./\

Provalo online!

R , 85 byte

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

Provalo online!

Input da stdin e output a stdout.

Ogni riga deve essere terminata da un avanzamento riga / ritorno a capo / CRLF e viene stampata con una nuova riga corrispondente. Pertanto, gli input devono avere un avanzamento riga finale.

Gelatina , 5 4 byte

U¹ƭ€

Provalo online!

Grazie HyperNeutrino per -1 byte! (in realtà perché non ho mai saputo come ƭfunziona a causa della mancanza di documentazione, questa volta sono stato fortunato)

T-SQL, 65 byte

Le nostre regole di input standard consentono a SQL di immettere valori da una tabella preesistente e poiché SQL è intrinsecamente non ordinato, la tabella deve avere numeri di riga per conservare l'ordine di testo originale.

Ho definito la tabella con una colonna di identità in modo da poter semplicemente inserire in sequenza le righe di testo (non conteggiate per il totale dei byte):

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

Quindi per selezionare e invertire le righe alternate:

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

Nota che posso salvare 11 byte escludendo ORDER BY i, e che probabilmente restituirà l'elenco nell'ordine originale per qualsiasi lunghezza ragionevole (lo fa certamente per l'esempio di 4 righe). Ma SQL lo garantisce solo se includi ORDER BY, quindi se avessimo, per esempio, 10.000 righe, ne avremmo sicuramente bisogno.

Perl 6 , 44 byte

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

Provalo

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
}

Virgola delimitata:

Stax , 12 byte

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

Esegui ed esegui il debug

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

Delimitato da Newline:

Stax , 8 byte

Çε÷┘)¼M@

Esegui ed esegui il debug

ingresso:

ABC
def
GHI
jkl
MNO
pqr
STU

uscita per entrambi:

CBA
def
IHG
jkl
ONM
pqr
UTS

In realtà , 7 byte

;r'R*♀ƒ

Spiegazione:

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

Provalo online!

Alice , 13 byte

M%/RM\
d&\tO/

Provalo 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.

Standard ML (MLton), 51 bytes

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

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

Retina, 18 bytes

{O$^`\G.

*2G`
2A`

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

Wolfram Language (Mathematica), 33 bytes

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

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.

Folding 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.

CJam, 11 bytes

{2/Waf.%:~}

Try it online! (CJam array literals use spaces to separate elements)

Explanation:

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

Explanation for the Waf.% "black magic" part:

• W is a variable preinitialized to -1. a wraps an element in an array, so Wa is [-1].
• % pops a number n and an array a and takes every nth element of the array. When n is negative, it also reverses it, meaning that W% reverses an array.
• . followed by a binary operation applies that operation to corresponding elements of an array, so [1 2 3] [4 5 6] .+ is [5 7 9]. If one array is longer than the other, the elements are kept without modification, meaning that Wa.% reverses the first element of an array.
• f followed by a binary operation will take an element from the stack and then act like {<that element> <that operation>}%, that is, go through each element in the array, push its element, push the element first popped from the stack, run the operation, and then collect the results back into an array. This means that Wa.f% reverses the first element of every element in the array.

V, 4 bytes

òjæ$

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$

Swift, 90 85 82 72 bytes

-10 bytes thanks to @Mr.Xcoder

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

Ruby, 19 + 2 = 21 bytes

+2 bytes for -nl flags.

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

Try it online!

Explanation

Practically identical to the Perl 5 answer, though I hadn’t seen that one when I wrote this.

With whitespace, the code looks like this:

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

The -p option makes Ruby effectively wrap your script in a loop like this:

while gets
  # ...
  puts $_
end

The special variable $_ contains the last line read by gets, and $. contains the line number.

The -l enables automatic line ending processing, which automatically calls chop! on each input line, which removes the the \n before we reverse it.

GNU sed, 31 + 1 = 32 bytes

+1 byte for -r flag.

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

Try it online!

Explanation

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

Charcoal, 9 bytes

ＥＮ⎇﹪ι²⮌ＳＳ

Try it online! Link is to verbose version of code. Note: Charcoal doesn't know the length of the list, so I've added it as an extra element. Explanation:

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

Try It Online

Prints first line in reverse. Has a trailing newline.

Basically, it works by alternating between printing as it gets input and storing the input on the stack. When it reaches a newline or end of input, it prints out the stack, prints a newline, and modifies the character at 0,4 to be either a # or a no-op to change the mode. If it was the end of input, end the program