Relacionado, mas muito diferente.

Um boustrophedon é um texto em que todas as outras linhas de escrita são invertidas ou invertidas, com letras invertidas.

Nesse desafio, apenas reverteremos todas as outras linhas, mas deixaremos os caracteres reais usados ​​intactos. Você pode escolher quais linhas reverter, desde que sejam todas as outras.

Você pode colocar o texto em qualquer formato adequado, desde que ofereça zero ou mais linhas de ASCII imprimíveis, cada uma com zero ou mais caracteres.

Exemplos:

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

⊢∘⌽\

A entrada é um vetor de vetores de caracteres.

⌽é uma função que inverte um vetor (quando ⌽aplicado monadicamente).

⊢é " dex " - uma função que retorna seu argumento correto. Quando composto ( ∘) com outra função f, força o último a ser monádico, pois A ⊢∘f Bé equivalente a A ⊢ (f B)e, portanto f B,.

\é o operador de digitalização . g\A B C ...é o vetor em A (A g B) (A g (B g C)) ...que gé aplicado de forma diádica (notação de infixo). Substituindo ⊢∘⌽por gele simplifica:

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

As reversões nas posições pares (ou ímpares, dependendo de como você conta) são canceladas.

Experimente online!

Haskell , 26 bytes

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

Experimente online! Exemplo de uso: zipWith($)l ["abc","def","ghi"]rendimentos ["abc","fed","ghi"].

Explicação:

lé uma lista infinita de funções alternando entre a idfunção da entidade e a reversefunção.

A função principal fecha le a lista de entradas com o aplicativo de funções $, ou seja, uma entrada ["abc", "def", "ghi"]que obtemos [id$"abc", reverse$"def", id$"ghi"].

Casca , 4 bytes

z*İ_

Pega e retorna uma lista de seqüências de caracteres (o intérprete associa implicitamente o resultado por novas linhas antes de imprimir). A primeira string é invertida. Experimente online!

Explicação

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

No Husk, multiplicar uma sequência por um número a repete muitas vezes, também a revertendo se o número for negativo.

JavaScript (ES6), Firefox, 43 bytes

Esta versão abusa do algoritmo de classificação do Firefox . Ele gera lixo no Chrome e não altera as strings no Edge.

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

Casos de teste

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

Ou Experimente online! (Macaco aranha)

JavaScript (ES6), 45 bytes

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

Casos de teste

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 nos dois sentidos:

Experimente online! com⎕IO←1

Experimente online! com⎕IO←0

Como 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

linhas ímpares invertidas

$_=reverse if$.%2

linhas pares invertidas

$_=reverse if$|--

Após o comentário de @ Martin: a entrada precisa ter um avanço de linha à direita.

experimente online

Haskell , 27 bytes

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

Experimente online!

Haskell , 30 bytes

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

Experimente online!

Recursão FTW.

05AB1E , 5 4 bytes

εNFR

Experimente online!

Explicação

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

K (oK) , 17 14 bytes

Solução:

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

Experimente online!

Exemplo:

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

Explicação:

Aplique reverseem índices ímpares da 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:

• mudou &(#x)#0 1para &2!!#xsalvar 3 bytes

APL (Dyalog) , 12 bytes

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

Experimente online!

Python 2 , 40 36 bytes

-4 bytes graças a @ Mr.Xcoder

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

Experimente online!

Saídas modificando a lista de entrada

Python 2 , 43 bytes

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

Experimente online!

Alumínio , 66 bytes

hdqqkiddzhceyhhhhhdaeuzepkrlhcwdqkkrhzpkzerlhcwqopshhhhhdaosyhapzw

Experimente online!

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

  OUTPUT A NEWLINE
  hhhhhdao
syhapzw

J , 9 bytes

(,|.&.>)/

Reduza da direita para a esquerda, revertendo todas as seqüências no resultado e acrescentando a próxima sequência como está.

Experimente online!

Podemos fazer 6 usando a abordagem de ngn , mas haverá espaços extras:

]&|./\

Experimente online!

R , 85 bytes

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

Experimente online!

Entrada de stdin e saída para stdout.

Cada linha deve ser finalizada por um avanço de linha / retorno de carro / CRLF e é impressa com uma nova linha correspondente. Portanto, as entradas precisam ter um avanço de linha à direita.

Geléia , 5 4 bytes

U¹ƭ€

Experimente online!

Obrigado HyperNeutrino por -1 bytes! (na verdade, porque eu nunca soube como ƭfunciona devido à falta de documentação, desta vez tive sorte)

T-SQL, 65 bytes

Nossas regras de entrada padrão permitem que o SQL insira valores de uma tabela preexistente e, como o SQL é inerentemente desordenado, a tabela deve ter números de linha para preservar a ordem do texto original.

Eu defini a tabela com uma coluna de identidade para que possamos simplesmente inserir linhas de texto sequencialmente (não contadas no total de bytes):

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

Então, para selecionar e reverter linhas alternadas:

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

Note que eu posso salvar 11 bytes, excluindo o ORDER BY i, e que é provável para retornar a lista na ordem original para qualquer período razoável (que certamente não para o exemplo 4-line). Mas o SQL só garante isso se você incluir as ORDER BY, portanto, se tivéssemos, digamos, 10.000 linhas, definitivamente precisaríamos disso.

Perl 6 , 44 bytes

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

Tente

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
}

Delimitado por vírgula:

Stax , 12 bytes

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

Execute e depure

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

Nova linha delimitada:

Stax , 8 bytes

Çε÷┘)¼M@

Execute e depure

entrada:

ABC
def
GHI
jkl
MNO
pqr
STU

saída para ambos:

CBA
def
IHG
jkl
ONM
pqr
UTS

Na verdade , 7 bytes

;r'R*♀ƒ

Explicação:

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

Experimente online!

Alice , 13 bytes

M%/RM\
d&\tO/

Experimente online!

Entrada através de argumentos de linha de comando separados. Inverte a primeira linha (e todas as outras linhas depois disso).

Explicação

       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 padrão (MLton) , 51 bytes

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

Experimente online! Exemplo de uso: $ ["abc","def","ghi"]rendimentos ["abc","fed","ghi"].

Explicação:

$é uma função recorrente em uma lista de seqüências de caracteres. Ele pega duas strings ae, bda lista, mantém a primeira inalterada e reverte a segunda, transformando a string em uma lista de caracteres ( explode), invertendo a lista ( rev) e transformando-a novamente em uma string ( implode).

Retina , 18 bytes

{O$^`\G.

*2G`
2A`

Experimente online! Explicação: O primeiro estágio inverte a primeira linha e, em seguida, o segundo estágio imprime as duas primeiras linhas, após o que o terceiro estágio as exclui. O programa inteiro se repete até não sobrar nada. Uma nova linha à direita pode ser removida ao custo de um líder ;.

Wolfram Language (Mathematica) , 33 bytes

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

Experimente online!

Como funciona

StringReverse@*Append, quando recebe uma lista de cadeias e outra como entrada, adiciona a cadeia ao final da lista e depois reverte todas as cadeias.

FoldAo inserir a entrada com relação ao acima, significa que:

• Inverta a primeira linha.
• Adicione a segunda linha ao final e inverta as duas.
• Adicione a terceira linha ao final e inverta as três.
• Adicione a quarta linha no final e inverta as quatro.
• E assim por diante, até ficarmos sem linhas.

Cada linha é revertida uma vez menos que a linha anterior, portanto as linhas alternam a direção.

CJam , 11 bytes

{2/Waf.%:~}

Experimente online! (Os literais da matriz CJam usam espaços para separar elementos)

Explicação:

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

Explicação para a Waf.%parte "magia negra":

• Wé uma variável pré-inicializada para -1. aagrupa um elemento em uma matriz, assim Waé [-1].
• %aparece um número ne uma matriz ae pega todos os nelementos da matriz. Quando né negativo, também o inverte, o que significa que W%inverte uma matriz.
• .seguido por uma operação binária aplica essa operação aos elementos correspondentes de uma matriz, assim [1 2 3] [4 5 6] .+é [5 7 9]. Se uma matriz for mais longa que a outra, os elementos serão mantidos sem modificação, o que significa que Wa.%reverte o primeiro elemento de uma matriz.
• fseguido de uma operação binária pegará um elemento da pilha e, em seguida, agirá como {<that element> <that operation>}%, ou seja, percorrer cada elemento da matriz, empurrar seu elemento, empurrar o elemento que primeiro saiu da pilha, executar a operação e coletar os resultados de volta para uma matriz. Isso significa que Wa.f%reverte o primeiro elemento de cada elemento da matriz.

V , 4 bytes

òjæ$

Experimente 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$

Rápido , 90 85 82 72 bytes

-10 bytes graças a @ Mr.Xcoder

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

Ruby , 19 + 2 = 21 bytes

+2 bytes para -nlsinalizadores.

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

Experimente online!

Explicação

Praticamente idêntico à resposta do Perl 5 , embora eu não tivesse visto essa quando escrevi isso.

Com espaço em branco, o código fica assim:

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

A -popção faz com que o Ruby efetivamente envolva seu script em um loop como este:

while gets
  # ...
  puts $_
end

A variável especial $_contém a última linha lida por getse$. contém o número da linha.

O -lpossibilita linha automática terminando de processamento, que chama automaticamente chop!em cada linha de entrada, que remove o o \nantes de revertê-la.

GNU sed , 31 + 1 = 32 bytes

+1 byte para -rsinalizador.

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

Experimente online!

Explicação

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

Carvão , 9 bytes

ＥＮ⎇﹪ι²⮌ＳＳ

Experimente online! Link é a versão detalhada do código. Nota: O carvão vegetal não sabe o comprimento da lista, então eu o adicionei como um elemento extra. Explicação:

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

Experimente Online

Imprime a primeira linha no sentido inverso. Tem uma nova linha à direita.

Basicamente, ele funciona alternando entre a impressão à medida que recebe e armazenando a entrada na pilha. Quando atinge uma nova linha ou final de entrada, imprime a pilha, imprime uma nova linha e modifica o caractere em 0,4 para ser um # ou um não-op para alterar o modo. Se foi o fim da entrada, finalize o programa