Regeln

Das Programm sollte eine Zeichenfolge / ein Array von Wörtern als Eingabe erhalten. Für jedes Wort in der Zeichenfolge / dem Array wird das Wort rekonstruiert, indem Zeichen abwechselnd von der Vorder- und Rückseite des Wortes verwendet werden.

12345 678 9 -> 15243 687 9.

Anschließend werden die Wörter abwechselnd zwischen dem frühesten und dem zuletzt in der Zeichenfolge vorkommenden Wort neu angeordnet.

15243 687 9 -> 15243 9 687

Schließlich wird der String rekonstruiert, indem die Leerzeichen, Tabulatoren und Zeilenumbrüche an den Indexen platziert werden, an denen sie sich ursprünglich befanden, bevor das Ergebnis ausgegeben wurde.

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

Die Ausgabe sollte denselben Datentyp wie die Eingabe haben.

Standardlücken sind verboten

Beispiele

Eingabe:
Der schnelle Braunfuchs springt über den faulen Hund.
Ausgabe: Die
d.ogq kucil yaz bnrwo tehf xoo rvej supm

Eingabe:
Der schnelle Braunfuchs springt
über den faulen Hund.
Ausgabe: Die
d.ogq kucil yaz bnrwo
tehf xoo rvej supm

Eingang:
Aflack
Ausgang:
Akfcla

Das ist Code-Golf, also gewinnt der kürzeste Code

Jelly , 15 14  8 Bytes

Eine satte 6 Byte speichern von Dennis (durch die Flatten und Schimmel im Inneren Link bewegen 1 gibt es keine Notwendigkeit, spaltete sich in zwei und Kopf, und ein Flatten gibt es bereits , so dass sie eins werden!)

żṚFṁ
Ç€Ç

(aus den beiden Zeilen:, żṚFœs2Ḣund Ç€ÇFṁ⁸)

Probieren Sie es online!

Nimmt eine Reihe von Wörtern und gibt eine Reihe neuer Wörter zurück. (Die Fußzeile bei TIO ruft dies auf und fügt dem Array Leerzeichen hinzu, damit es gut ausgedruckt wird.)

Hinweis: Die Bearbeitung einer einzelnen Zeichenfolge, das Aufteilen auf Tabulatoren und Zeilenumbrüche sowie das erneute Zusammensetzen erwiesen sich als recht schwierig. Als ich sah, dass eine Liste von Wörtern eine Option war, wurde es viel einfacher!

Wie?

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

Nimmt eine Reihe von Wörtern auf und gibt sie aus.

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

Prüfung

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

String-Version, 112 Bytes

Nimmt einen String und gibt ihn aus.

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)

Prüfung

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 Bytes

74 Byte Code + 3 Byte für -0paFlags.

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

Probieren Sie es online!

Gespeichert 8 Bytes dank einer alten @Ton Hospel ‚s Post , wo ich‚gestohlen‘ s/../chop/reg. (Ich hatte vorher $c=y///c/2,s/.{$c}$//)

Perl 6 , 84 Bytes

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

Eingabe und Ausgabe einer Liste von Wörtern.

Wie es funktioniert

Innerhalb des Lambdas definierte ich ein weiteres Lambda, um die Drehung " Zeichen abwechselnd von vorne und hinten aufnehmen " durchzuführen :

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.

Dies funktioniert, weil der xxOperator eher wie ein Makro als eine Funktion ist, da er eine magische, faule Auswertung ermöglicht.

Dann im Hauptlambda:

                   [$_]                          # 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 Bytes

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

Dies ist eine Abwandlung der oben genannten Methode, bei der eine Zeichenfolge eingegeben und ausgegeben wird, wobei verschiedene Leerzeichen beibehalten werden.

Haskell , 115 95 93 98 95 Bytes

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

Mit anrufen (!)=<<(f=<<).f.words $ "some string". Probieren Sie es online!

Vielen Dank an @nimi für den Hinweis, dass ich die Herausforderung früher falsch verstanden habe.

Die Funktion fführt das Verdrehen einer Liste durch, sodass sie für Zeichenfolgen (Liste der Zeichen) und eine Liste der Zeichenfolgen verwendet werden kann. a!bFügt das Leerzeichen von string bin string ein a.

(!)=<<(f=<<).f.wordsist gleichbedeutend mit \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"