Relacionado pero muy diferente.

Un boustrophedon es un texto donde se invierte o invierte cualquier otra línea de escritura, con letras invertidas.

En este desafío, solo revertiremos cada línea, pero dejaremos los caracteres reales utilizados intactos. Puede elegir qué líneas invertir, siempre que sean todas las demás.

Puede tomar el texto en cualquier formato adecuado siempre que admita cero o más líneas de ASCII imprimibles, cada una con cero o más caracteres.

Ejemplos:

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

⊢∘⌽\

La entrada es un vector de vectores de caracteres.

⌽es una función que invierte un vector (cuando ⌽se aplica monádicamente).

⊢es " dex ", una función que devuelve su argumento correcto. Cuando compuesta ( ∘) con otra función fque obliga a este último a ser monádico como A ⊢∘f Bes equivalente a A ⊢ (f B)y por lo tanto f B.

\es el operador de escaneo . g\A B C ...es el vector A (A g B) (A g (B g C)) ...donde gse aplica de forma diádica (notación infija). Sustituyendo ⊢∘⌽para gque se simplifica a:

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

Las reversiones en posiciones pares (o impares, dependiendo de cómo cuente) se cancelan.

Pruébalo en línea!

Haskell , 26 bytes

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

Pruébalo en línea! Ejemplo de uso: zipWith($)l ["abc","def","ghi"]rendimientos ["abc","fed","ghi"].

Explicación:

les una lista infinita de funciones que alternan entre la idfunción de entidad y la reversefunción.

La función principal se comprime ly la lista de entrada con la aplicación de función $, que es para una entrada ["abc", "def", "ghi"]que obtenemos [id$"abc", reverse$"def", id$"ghi"].

Casco , 4 bytes

z*İ_

Toma y devuelve una lista de cadenas (el intérprete se une implícitamente al resultado mediante nuevas líneas antes de imprimir). La primera cadena se invierte. Pruébalo en línea!

Explicación

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

En Husk, multiplicar una cadena con un número lo repite muchas veces, y también lo invierte si el número es negativo.

JavaScript (ES6), Firefox, 43 bytes

Esta versión abusa del algoritmo de ordenación de Firefox . Genera basura en Chrome y no altera las cadenas en Edge.

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

Casos de prueba

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

O Pruébelo en línea! (Mono araña)

JavaScript (ES6), 45 bytes

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

Casos de prueba

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

Funciona en ambos sentidos:

Pruébalo en línea! con⎕IO←1

Pruébalo en línea! con⎕IO←0

Cómo funciona:

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

líneas impares invertidas

$_=reverse if$.%2

líneas pares invertidas

$_=reverse if$|--

Después del comentario de @ Martin: la entrada debe tener un salto de línea final.

pruébalo en línea

Haskell , 27 bytes

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

Pruébalo en línea!

Haskell , 30 bytes

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

Pruébalo en línea!

Recursion FTW.

05AB1E , 5 4 bytes

εNFR

Pruébalo en línea!

Explicación

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

K (oK) , 17 14 bytes

Solución:

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

Pruébalo en línea!

Ejemplo:

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

Explicación:

Aplicar reverseen índices impares de la lista de entrada:

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

Notas:

• cambiado &(#x)#0 1para &2!!#xguardar 3 bytes

APL (Dyalog) , 12 bytes

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

Pruébalo en línea!

Python 2 , 40 36 bytes

-4 bytes gracias a @ Mr.Xcoder

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

Pruébalo en línea!

Salidas modificando la lista de entrada

Python 2 , 43 bytes

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

Pruébalo en línea!

Aluminio , 66 bytes.

hdqqkiddzhceyhhhhhdaeuzepkrlhcwdqkkrhzpkzerlhcwqopshhhhhdaosyhapzw

Pruébalo en línea!

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

  OUTPUT A NEWLINE
  hhhhhdao
syhapzw

J , 9 bytes

(,|.&.>)/

Reduzca de derecha a izquierda, invirtiendo todas las cadenas en el resultado y anteponiendo la siguiente cadena como está.

Pruébalo en línea!

Podemos hacer 6 usando el enfoque de ngn , pero habrá espacios adicionales:

]&|./\

Pruébalo en línea!

R , 85 bytes

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

Pruébalo en línea!

Entrada de stdin y salida a stdout.

Cada línea debe terminar con un salto de línea / retorno de carro / CRLF, y se imprime con una nueva línea correspondiente. Por lo tanto, las entradas deben tener un salto de línea final.

Jalea , 5 4 bytes

U¹ƭ€

Pruébalo en línea!

Gracias HyperNeutrino por -1 bytes! (en realidad porque nunca supe cómo ƭfunciona debido a la falta de documentación, esta vez tuve suerte)

T-SQL, 65 bytes

Nuestras reglas de entrada estándar permiten que SQL ingrese valores de una tabla preexistente , y dado que SQL está inherentemente desordenado, la tabla debe tener números de fila para preservar el orden del texto original.

He definido la tabla con una columna de identidad para que simplemente podamos insertar líneas de texto secuencialmente (sin contar para el total de bytes):

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

Entonces, para seleccionar e invertir filas alternas:

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

Tenga en cuenta que puedo guardar 11 bytes excluyendo el ORDER BY i, y que es probable que devuelva la lista en el orden original para cualquier longitud razonable (ciertamente lo hace para el ejemplo de 4 líneas). Pero SQL solo lo garantiza si incluye el ORDER BY, por lo que si tuviéramos, digamos, 10,000 filas, definitivamente lo necesitaríamos.

Perl 6 , 44 bytes

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

Intentalo

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
}

Separado por comas:

Stax , 12 bytes

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

Ejecutar y depurarlo

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

Nueva línea delimitada:

Stax , 8 bytes

Çε÷┘)¼M@

Ejecutar y depurarlo

entrada:

ABC
def
GHI
jkl
MNO
pqr
STU

salida para ambos:

CBA
def
IHG
jkl
ONM
pqr
UTS

En realidad , 7 bytes

;r'R*♀ƒ

Explicación:

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

Pruébalo en línea!

Alice , 13 bytes

M%/RM\
d&\tO/

Pruébalo en línea!

Entrada a través de argumentos de línea de comandos separados. Invierte la primera línea (y todas las demás líneas después de eso).

Explicación

       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 estándar (MLton) , 51 bytes

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

Pruébalo en línea! Ejemplo de uso: $ ["abc","def","ghi"]rendimientos ["abc","fed","ghi"].

Explicación:

$es una función que se repite en una lista de cadenas. Toma dos cadenas ay bde la lista, mantiene la primera sin cambios e invierte la segunda transformando la cadena en una lista de caracteres ( explode), invirtiendo la lista ( rev) y volviéndola a una cadena ( implode).

Retina , 18 bytes

{O$^`\G.

*2G`
2A`

Pruébalo en línea! Explicación: La primera etapa invierte la primera línea, luego la segunda etapa imprime las dos primeras líneas, después de lo cual la tercera etapa las elimina. Todo el programa se repite hasta que no quede nada. Una nueva línea final podría eliminarse a costa de un líder ;.

Wolfram Language (Mathematica) , 33 bytes

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

Pruébalo en línea!

Cómo funciona

StringReverse@*Append, cuando se le da una lista de cadenas y otra cadena como entrada, agrega la cadena al final de la lista y luego invierte todas las cadenas.

FoldLa entrada con respecto a lo anterior significa que nosotros:

• Invierte la primera línea.
• Agregue la segunda línea al final e invierta ambos.
• Agregue la tercera línea al final e invierta los tres.
• Agregue la cuarta línea al final e invierta los cuatro.
• Y así sucesivamente, hasta que se nos acaben las líneas.

Cada línea se invierte una vez menos que la línea anterior, por lo que las líneas alternan la dirección.

CJam , 11 bytes

{2/Waf.%:~}

Pruébalo en línea!(Los literales de matriz CJam usan espacios para separar elementos)

Explicación:

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

Explicación de la parte de Waf.%"magia negra":

• Wes una variable preinicializada a -1. aenvuelve un elemento en una matriz, por lo que Waes[-1] .
• %muestra un número ny una matriz ay toma todos nlos elementos de la matriz. Cuando nes negativo, también lo invierte, lo que significa que W%invierte una matriz.
• .seguido de una operación binaria aplica esa operación a los elementos correspondientes de una matriz, por lo que [1 2 3] [4 5 6] .+es[5 7 9] . Si una matriz es más larga que la otra, los elementos se mantienen sin modificación, lo que significa queWa.% invierte el primer elemento de una matriz.
• fseguido de una operación binaria, tomará un elemento de la pila y luego actuará como {<that element> <that operation>}%, es decir, pasará por cada elemento de la matriz, empujará su elemento, empujará el elemento que primero salió de la pila, ejecutará la operación y luego recopilará los resultados de nuevo en una matriz. Esto significa que Wa.f%invierte el primer elemento de cada elemento de la matriz.

V , 4 bytes

òjæ$

Pruébalo en línea!

ò      ' <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 gracias a @ Mr.Xcoder

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

Ruby , 19 + 2 = 21 bytes

+2 bytes para -nlbanderas.

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

Pruébalo en línea!

Explicación

Prácticamente idéntico a la respuesta de Perl 5 , aunque no la había visto cuando escribí esto.

Con espacios en blanco, el código se ve así:

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

La -popción hace que Ruby efectivamente envuelva su script en un bucle como este:

while gets
  # ...
  puts $_
end

La variable especial $_contiene la última línea leída por gets, y $.contiene el número de línea.

El -lpermite que termina el procesamiento automático de línea, que llama automáticamente chop!en cada línea de entrada, que elimina el del \nantes revertirla.

GNU sed , 31 + 1 = 32 bytes

+1 byte para -rbandera.

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

Pruébalo en línea!

Explicació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

Carbón de leña , 9 bytes

ＥＮ⎇﹪ι²⮌ＳＳ

Pruébalo en línea! El enlace es a la versión detallada del código. Nota: el carbón vegetal no conoce la longitud de la lista, así que lo agregué como un elemento adicional. Explicación:

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

Pruébalo en línea

Imprime la primera línea al revés. Tiene una nueva línea final.

Básicamente, funciona alternando entre impresión a medida que ingresa y almacena la entrada en la pila. Cuando llega a una nueva línea o al final de la entrada, imprime la pila, imprime una nueva línea y modifica el carácter a 0,4 para que sea un # o un no-op para cambiar el modo. Si fue el final de la entrada, finalice el programa