Regole

Il programma dovrebbe ricevere una stringa / matrice di parole come input. Per ogni parola nella stringa / matrice, ricostruirà la parola prendendo i caratteri in modo alternato dalla parte anteriore e posteriore della parola.

12345 678 9 -> 15243 687 9.

Riorganizzerà quindi le parole in modo alternato tra la prima e l'ultima occorrenza nella stringa.

15243 687 9 -> 15243 9 687

Infine, ricostruirà la stringa posizionando gli spazi, le schede e le nuove righe negli indici in cui erano inizialmente posizionati prima di produrre il risultato.

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

L'output deve avere lo stesso tipo di dati dell'input.

Sono vietate le scappatoie standard

Esempi

Input:
la rapida volpe marrone salta sopra il cane pigro.
Uscita:
Teh d.ogq kucil yaz bnrwo tehf xoo rvej supm

Input:
la rapida volpe marrone salta
sopra il cane pigro.
Uscita:
Teh d.ogq kucil yaz bnrwo
tehf xoo rvej supm

Input:
Aflack
Output:
Akfcla

Questo è code-golf, quindi vince il codice più breve

Gelatina , 15 14  8 byte

UN enorme salvataggio di 6 byte da Dennis (spostando l'appiattimento e lo stampo all'interno del collegamento 1 non è necessario dividere in due e dirigersi, e un appiattimento è già lì in modo che diventino uno!)

żṚFṁ
Ç€Ç

(dalle due righe:, żṚFœs2Ḣe Ç€ÇFṁ⁸)

Provalo online!

Accetta una serie di parole e restituisce una serie di nuove parole. (Il piè di pagina di TIO chiama questo e unisce l'array con gli spazi in modo che si stampi bene.)

Nota: la gestione di una singola stringa, la divisione in spazi di tabulazioni e newline, quindi il riassemblaggio si stava rivelando piuttosto complicato; una volta ho visto che un elenco di parole era un'opzione le cose sono diventate molto più facili!

Come?

Ç€Ç - 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 byte

Prende e genera una serie di parole.

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

Test

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."])
  )
);

Versione stringa, 112 byte

Prende e genera una stringa.

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)

Test

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 byte

74 byte di codice + 3 byte per i -0paflag.

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

Provalo online!

Salvato 8 byte grazie ad un vecchio @Ton Hospel s' posta in cui ho 'rubato' s/../chop/reg. (Avevo precedentemente $c=y///c/2,s/.{$c}$//)

Perl 6 , 84 byte

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

Inserisce ed emette un elenco di parole.

Come funziona

All'interno della lambda, ho definito un'altra lambda per eseguire la torsione " prendendo i personaggi in modo alternato dalla parte anteriore e posteriore ":

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.

Questo funziona perché l' xxoperatore è più simile a una macro che a una funzione, in quanto fornisce una valutazione pigra e magica.

Quindi nella 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 byte

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

Questa è una variante di quanto sopra, che input e output di una stringa - preservando diversi caratteri di spazi bianchi.

Haskell , 115 95 93 98 95 byte

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

Chiama con (!)=<<(f=<<).f.words $ "some string".Provalo online!

Grazie a @nimi per aver sottolineato che ho letto male la sfida in precedenza.

La funzione fesegue la torsione su un elenco, quindi può essere utilizzata su stringhe (elenco di caratteri) e un elenco di stringhe. a!binserisce lo spazio bianco della stringa bnella stringaa .

(!)=<<(f=<<).f.wordsè equivalente a \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"