Relatif mais très différent.

Un boustrophédon est un texte dans lequel toutes les lignes d'écriture sont inversées ou inversées, avec des lettres inversées.

Dans ce défi, nous allons simplement inverser toutes les lignes, mais nous laisserons les caractères réels utilisés. Vous pouvez choisir les lignes à inverser, à condition que ce soit toutes les autres.

Vous pouvez utiliser le texte dans n’importe quel format approprié, à condition de ne pas prendre en charge zéro ou plusieurs lignes d’ASCII imprimables, chacune contenant zéro caractère ou plus.

Exemples:

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

⊢∘⌽\

L'entrée est un vecteur de vecteurs de caractères.

⌽est une fonction qui inverse un vecteur ( ⌽s’applique de façon monadique).

⊢est " dex " - une fonction qui retourne son argument correct. Lorsque composé ( ∘) avec une autre fonction, fil oblige celle-ci à être monadique, ce qui A ⊢∘f Best équivalent à A ⊢ (f B)et par conséquent f B.

\est l' opérateur de numérisation . g\A B C ...est le vecteur A (A g B) (A g (B g C)) ...où gest appliqué dyadiquement (notation infixe). Le remplacement ⊢∘⌽pour gelle simplifie à:

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

Les inversions aux positions paires (ou impaires, selon votre décompte) s’annulent.

Essayez-le en ligne!

Haskell , 26 octets

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

Essayez-le en ligne! Exemple d'utilisation: zipWith($)l ["abc","def","ghi"]rendements ["abc","fed","ghi"].

Explication:

lest une liste infinie de fonctions alternant entre la idfonction d'entité et la reversefonction.

La fonction principale zips let la liste des entrées avec l’application de fonction $, c’est pour une entrée que ["abc", "def", "ghi"]nous obtenons [id$"abc", reverse$"def", id$"ghi"].

Husk , 4 octets

z*İ_

Prend et retourne une liste de chaînes (l'interpréteur joint implicitement le résultat par des lignes nouvelles avant l'impression). La première chaîne est inversée. Essayez-le en ligne!

Explication

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

Dans Husk, multiplier une chaîne avec un nombre le répète plusieurs fois, l'inversant également si le nombre est négatif.

JavaScript (ES6), Firefox, 43 octets

Cette version abuse de l'algorithme de tri de Firefox . Il génère des déchets sur Chrome et ne modifie pas les chaînes sur Edge.

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

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

Ou essayez-le en ligne! (SpiderMonkey)

JavaScript (ES6), 45 octets

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

Cas de 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 octets

⌽¨@{2|⍳≢⍵}

Fonctionne dans les deux sens:

Essayez-le en ligne! avec⎕IO←1

Essayez-le en ligne! avec⎕IO←0

Comment ça marche:

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

lignes impaires inversées

$_=reverse if$.%2

même les lignes inversées

$_=reverse if$|--

Après le commentaire de @ Martin: l'entrée doit avoir un retour à la ligne final.

essayez-le en ligne

Haskell , 27 octets

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

Essayez-le en ligne!

Haskell , 30 octets

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

Essayez-le en ligne!

Récursion FTW.

05AB1E , 5 4 octets

εNFR

Essayez-le en ligne!

Explication

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

K (oK) , 17 14 octets

Solution:

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

Essayez-le en ligne!

Exemple:

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

Explication:

Appliquer reverseaux indices impairs de la liste d'entrée:

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

Remarques:

• éteint &(#x)#0 1pour &2!!#xéconomiser 3 octets

APL (Dyalog) , 12 octets

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

Essayez-le en ligne!

Python 2 , 40 36 octets

-4 octets grâce à @ Mr.Xcoder

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

Essayez-le en ligne!

Sorties en modifiant la liste des entrées

Python 2 , 43 octets

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

Essayez-le en ligne!

Aluminium , 66 octets

hdqqkiddzhceyhhhhhdaeuzepkrlhcwdqkkrhzpkzerlhcwqopshhhhhdaosyhapzw

Essayez-le en ligne!

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

  OUTPUT A NEWLINE
  hhhhhdao
syhapzw

J , 9 octets

(,|.&.>)/

Réduisez de droite à gauche, en inversant toutes les chaînes du résultat et en ajoutant la chaîne suivante au début.

Essayez-le en ligne!

Nous pouvons faire 6 en utilisant l'approche de ngn , mais il y aura des espaces supplémentaires:

]&|./\

Essayez-le en ligne!

R , 85 octets

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

Essayez-le en ligne!

Entrée de stdin et sortie sur stdout.

Chaque ligne doit être terminée par un saut de ligne / retour chariot / CRLF, et elle est imprimée avec une nouvelle ligne correspondante. Donc, les entrées doivent avoir un retour à la ligne final.

Gelée , 5 à 4 octets

U¹ƭ€

Essayez-le en ligne!

Merci HyperNeutrino pour -1 octets! (en fait parce que je n'ai jamais su comment ƭfonctionne par manque de documentation, cette fois j'ai eu de la chance)

T-SQL, 65 octets

Nos règles d'entrée standard permettent à SQL d' entrer des valeurs à partir d'une table préexistante. Etant donné que SQL n'est pas ordonné, la table doit comporter des numéros de ligne pour préserver l'ordre du texte d'origine.

J'ai défini la table avec une colonne d'identité afin que nous puissions simplement insérer des lignes de texte séquentiellement (non comptées dans le total d'octets):

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

Donc, pour sélectionner et inverser les lignes en alternance:

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

Notez que je peux économiser 11 octets en excluant le ORDER BY i, ce qui est susceptible de renvoyer la liste dans l'ordre d'origine pour une longueur raisonnable (c'est certainement le cas pour l'exemple de 4 lignes). Mais SQL ne le garantit que si vous incluez le ORDER BY, donc si nous avions, par exemple, 10 000 lignes, nous en aurions certainement besoin.

Perl 6 , 44 octets

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

L'essayer

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
}

Délimité par des virgules:

Stax , 12 octets

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

Exécuter et déboguer

entrée: ABC, def, GHI, jkl, MNO, pqr, STU

Délimité par une nouvelle ligne:

Stax , 8 octets

Çε÷┘)¼M@

Exécuter et déboguer

contribution:

ABC
def
GHI
jkl
MNO
pqr
STU

sortie pour les deux:

CBA
def
IHG
jkl
ONM
pqr
UTS

En fait , 7 octets

;r'R*♀ƒ

Explication:

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

Essayez-le en ligne!

Alice , 13 octets

M%/RM\
d&\tO/

Essayez-le en ligne!

Entrée via des arguments de ligne de commande séparés. Inverse la première ligne (et toutes les autres lignes après).

Explication

       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 octets

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

Essayez-le en ligne! Exemple d'utilisation: $ ["abc","def","ghi"]rendements ["abc","fed","ghi"].

Explication:

$est une fonction récurrente sur une liste de chaînes. Il prend deux chaînes aet, bde la liste, la première reste inchangée et inverse la seconde en transformant la chaîne en liste de caractères ( explode), en inversant la liste ( rev) et en la retournant en chaîne ( implode).

Retina , 18 octets

{O$^`\G.

*2G`
2A`

Essayez-le en ligne! Explication: La première étape inverse la première ligne, puis la deuxième étape imprime les deux premières lignes, après quoi la troisième étape les supprime. L'ensemble du programme se répète ensuite jusqu'à ce qu'il ne reste plus rien. Une nouvelle ligne peut être supprimée au prix d’une avance ;.

Wolfram Language (Mathematica) , 33 octets

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

Essayez-le en ligne!

Comment ça marche

StringReverse@*Append, lorsqu’une liste de chaînes et une autre chaîne sont données en entrée, ajoute la chaîne à la fin de la liste, puis inverse toutes les chaînes.

Foldl’entrée par rapport à ce qui précède signifie que nous:

• Inverser la première ligne.
• Ajoutez la deuxième ligne à la fin et inversez les deux.
• Ajoutez la troisième ligne à la fin et inversez les trois.
• Ajoutez la quatrième ligne à la fin et inversez les quatre.
• Et ainsi de suite, jusqu'à ce que nous manquions de lignes.

Chaque ligne est inversée une fois de moins que la ligne précédente, de sorte que les lignes changent de direction.

CJam , 11 octets

{2/Waf.%:~}

Essayez-le en ligne! (Les littéraux de tableau CJam utilisent des espaces pour séparer des éléments)

Explication:

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

Explication de la partie Waf.%"magie noire":

• West une variable pré-initialisée à -1. aenroule un élément d'un tableau, donc Waest [-1].
• %fait apparaître un nombre net un tableau aet prend chaque ne élément du tableau. Quand nest négatif, il l'inverse également, ce qui signifie que l' W%inverse d'un tableau.
• .suivi d'une opération binaire applique cette opération aux éléments correspondants d'un tableau, il en [1 2 3] [4 5 6] .+est de même [5 7 9]. Si un tableau est plus long que l'autre, les éléments sont conservés sans modification, ce qui signifie que Wa.%le premier élément est inversé.
• fsuivi d'une opération binaire va prendre un élément de la pile et ensuite agir {<that element> <that operation>}%, c'est-à-dire passer en revue chaque élément du tableau, pousser son élément, pousser l'élément extrait de la pile, exécuter l'opération, puis collecter les résultats. retour dans un tableau. Cela signifie que Wa.f%renverse le premier élément de chaque élément du tableau.

V , 4 octets

òjæ$

Essayez-le en ligne!

ò      ' <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 octets

-10 octets grâce à @ Mr.Xcoder

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

Ruby , 19 + 2 = 21 octets

+2 octets pour les -nldrapeaux.

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

Essayez-le en ligne!

Explication

Pratiquement identique à la réponse à Perl 5 , bien que je n’aie pas vu celle-là lorsque j’ai écrit ceci.

Avec les espaces, le code ressemble à ceci:

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

L’ -poption permet à Ruby d’envelopper efficacement votre script dans une boucle comme celle-ci:

while gets
  # ...
  puts $_
end

La variable spéciale $_contient la dernière ligne lue par getset $.contient le numéro de ligne.

La -lpermet la ligne automatique de fin de traitement, qui appelle automatiquement chop!sur chaque ligne d'entrée, ce qui élimine le l' \navant le renverser.

GNU sed , 31 + 1 = 32 octets

+1 octet pour le -rdrapeau.

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

Essayez-le en ligne!

Explication

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

Charbon de bois , 9 octets

ＥＮ⎇﹪ι²⮌ＳＳ

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Note: Charcoal ne connaît pas la longueur de la liste, je l'ai donc ajoutée en tant qu'élément supplémentaire. Explication:

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

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

Essayez-le en ligne

Imprime la première ligne en sens inverse. A une nouvelle ligne de fuite.

Fondamentalement, cela fonctionne en alternant entre l’impression au fur et à mesure de l’entrée et le stockage de l’entrée sur la pile. Lorsqu'il atteint une nouvelle ligne ou une fin d'entrée, il imprime la pile, une nouvelle ligne et modifie le caractère à 0,4 pour qu'il soit un # ou un no-op pour changer de mode. Si c'était la fin de la saisie, terminez le programme