Règles

Le programme doit recevoir une chaîne / un tableau de mots en entrée. Pour chaque mot de la chaîne / du tableau, il reconstruira le mot en prenant alternativement les caractères à l'avant et à l'arrière du mot.

12345 678 9 -> 15243 687 9.

Il réorganisera ensuite les mots de manière alternée entre le premier et le dernier mot apparaissant dans la chaîne.

15243 687 9 -> 15243 9 687

Enfin, il reconstruira la chaîne en plaçant les espaces, les tabulations et les sauts de ligne aux index où ils étaient initialement situés avant de produire le résultat.

12345 678 9-> 15243 687 9 -> 15243 9 687 -> 15243 968 7

La sortie doit être du même type de données que l'entrée.

Les échappatoires standard sont interdites

Exemples

Entrée:
Le renard brun rapide saute par-dessus le chien paresseux.
Production:
Teh d.ogq kucil yaz bnrwo tehf xoo rvej supm

Entrée:
Le renard brun rapide saute par-
dessus le chien paresseux.
Sortie:
Teh d.ogq kucil yaz bnrwo
tehf xoo rvej supm

Entrée:
Aflack
Sortie:
Akfcla

C'est le code-golf donc le code le plus court gagne

Gelée , 15 14  8 octets

Un énorme gain de 6 octets de Dennis (en déplaçant l'aplatissement et le moule à l'intérieur du lien 1, il n'est pas nécessaire de le diviser en deux et de la tête, et un aplatissement est déjà là pour qu'ils deviennent un!)

żṚFṁ
Ç€Ç

(à partir des deux lignes:, żṚFœs2Ḣet Ç€ÇFṁ⁸)

Essayez-le en ligne!

Prend un tableau de mots et renvoie un tableau de nouveaux mots. (Le pied de page de TIO appelle cela et joint le tableau avec des espaces pour qu'il s'imprime bien.)

Remarque - la gestion d'une seule chaîne, la division des espaces de tabulations et des sauts de ligne, puis le réassemblage se sont avérés plutôt délicats; une fois que j'ai vu qu'une liste de mots était une option, les choses sont devenues beaucoup plus faciles!

Comment?

Ç€Ç - Main link: list of words
Ç€  - call the last link (1) as a monad for €ach word
  Ç - call the last link (1) as a monad for the result

żṚFṁ - Link 1: Do a twist: list (here, a list of words or characters)
                            e.g. input = [A,B,C,D,E,F,G]
ż    - zip the list with                 [A,    B,    C,    D,    E,    F,    G]
 Ṛ   - the reverse of the list             [G,    F,    E,    D,    C,    B,    A]
                                        [[A,G],[B,F],[C,E],[D,D],[E,C],[F,B],[G,A]]
  F  - flatten into a single list        [A,G,  B,F,  C,E,  D,D,  E,C,  F,B,  G,A]
                                         [A,G,B,F,C,E,D,D,E,C,F,B,G,A]
   ṁ - mould like the input list         [A,G,B,F,C,E,D]

JavaScript (ES6), 89 octets

Prend et sort un tableau de mots.

a=>a.map(w=>(F=([a,...b])=>a?a+(b.pop()||'')+F(b):'')(a.map(F)).slice(p,p+=w.length),p=0)

Tester

let f =

a=>a.map(w=>(F=([a,...b])=>a?a+(b.pop()||'')+F(b):'')(a.map(F)).slice(p,p+=w.length),p=0)

console.log(
  JSON.stringify(
    f(["The","quick","brown","fox","jumps","over","the","lazy","dog."])
  )
);

Version chaîne, 112 octets

Prend et sort une chaîne.

s=>s.replace(/\S+/g,w=>(F=([a,...b])=>a?a+(b.pop()||'')+F(b):'')(s.split(/\s/).map(F)).slice(p,p+=w.length),p=0)

Tester

let f =

s=>s.replace(/\S+/g,w=>(F=([a,...b])=>a?a+(b.pop()||'')+F(b):'')(s.split(/\s/).map(F)).slice(p,p+=w.length),p=0)

console.log(f(`The quick brown fox jumps over the lazy dog.`))

console.log(f(`The quick brown fox jumps
over the lazy dog.`))

console.log(f(`Aflack`))

Perl , 77 octets

74 octets de code + 3 octets pour les -0padrapeaux.

map{s/.\K/chop/ge,s/../chop/reg}@F;s/\S/($r||=$F[$i++].pop@F)=~s%.%%,$&/ge

Essayez-le en ligne!

8 octets enregistrés grâce à un ancien @Ton Hospel de poste où je « volé » s/../chop/reg. (J'avais auparavant $c=y///c/2,s/.{$c}$//)

Perl 6 , 84 octets

{my &t={(|(.shift,.pop)xx*)[^$_]}
map({|t [.comb]},t [$_]).rotor($_».chars)».join}

Entre et sort une liste de mots.

Comment ça fonctionne

À l'intérieur de la lambda, j'ai défini une autre lambda pour effectuer la torsion "en prenant alternativement les personnages de l'avant et de l'arrière ":

my &t={                        }   # Lambda, assigned to a variable.
          .shift,.pop              # Remove an element from the front an back,
                      xx*          # an infinite number of times,
        |(           )             # and make sure this infinite list is flattened.
                          [^$_]    # Take as many elements as the input had elements.

Cela fonctionne parce que le xx opérateur ressemble plus à une macro qu'à une fonction, en ce sens qu'il fournit une évaluation paresseuse magique.

Puis dans la lambda principale:

                   [$_]                          # Create a fresh array from the input,
                 t                               # and twist it (destructively).
map({          },                                # For each element (i.e. word):
      t [.comb]                                  #   Split it into characters and twist them,
     |                                           #   and slip them into the outer list.
                        .rotor($_».chars)        # Partition this flat list of characters,
                               $_».chars         # using the original word lengths.
                                         ».join  # Turn each sub-list into a word.

Perl 6 , 87 octets

{my &t={(|(.shift,.pop)xx*)[^$_]}
my @a=map {|t [.comb]},t [.words];S:g/\S/{@a.shift}/}

Il s'agit d'une variante de ce qui précède, qui entre et sort une chaîne - en préservant différents caractères d'espaces blancs.

Haskell , 115 95 93 98 95 octets

f(a:b)=a:f(reverse b)
f e=e
a!(y:z)|elem y" \t\n"=y:a!z|b:c<-a=b:c!z
a!z=z
(!)=<<(f=<<).f.words

Appelez avec (!)=<<(f=<<).f.words $ "some string". Essayez-le en ligne!

Merci à @nimi d'avoir souligné que j'avais mal lu le défi plus tôt.

La fonction feffectue la torsion sur une liste, elle peut donc être utilisée sur des chaînes (liste de caractères) et une liste de chaînes. a!binsère l'espace blanc de la chaîne bdans la chaîne a.

(!)=<<(f=<<).f.wordséquivaut à \s0 -> (concatMap f . f . words $ s0) ! s0:

            s0 = "The quick brown fox jumps\nover the lazy dog."
      words s0 = ["The","quick","brown","fox","jumps","over","the","lazy","dog."] = s1
          f s1 = ["The","dog.","quick","lazy","brown","the","fox","over","jumps"] = s2
concatMap f s2 = "Tehd.ogqkucilyazbnrwotehfxoorvejsupm"                           = s3
       s3 ! s0 = "Teh d.ogq kucil yaz bnrwo\ntehf xoo rvej supm"