ルール

プログラムは、入力として単語の文字列/配列を受け取る必要があります。文字列/配列内の各単語について、単語の前後から交互に文字を取得して単語を再構築します。

12345 678 9-> 15243 687 9。

次に、文字列内で最初に出現した単語と最新の単語を交互に並べ替えます。

15243 687 9-> 15243 9 687

最後に、結果を出力する前に最初に配置されたインデックスにスペース、タブ、および改行を配置することにより、文字列を再構築します。

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

出力は入力と同じデータ型でなければなりません。

標準的な抜け穴は禁止されています

例

入力：
速い茶色のキツネが怠laな犬を飛び越えます。
出力：
Teh d.ogq kucil yaz bnrwo tehf xoo rvej supm

入力：
速い茶色のキツネ
が怠laな犬を飛び越えます。
出力：
Teh d.ogq kucil yaz bnrwo
tehf xoo rvej supm

入力：
Aflack
出力：
Akfcla

これはコードゴルフなので、最短のコードが勝ちます

ゼリー、15 14  8 バイト

なんとから保存6バイトデニス（リンク1の内側に平らに金型を移動することによって、そこに2と頭に分割する必要はなく、彼らが一つになるように、平坦化がすでにあります！）

żṚFṁ
Ç€Ç

（2行から：żṚFœs2Ḣ、およびÇ€ÇFṁ⁸）

オンラインでお試しください！

単語の配列を取り、新しい単語の配列を返します。（TIOのフッターがこれを呼び出して、配列をスペースで結合し、うまく印刷されるようにします。）

注-単一の文字列を処理し、タブスペースと改行で分割し、再構築することは実際にはかなり難しいことでした。単語のリストがオプションであることがわかったら、作業がずっと簡単になりました！

どうやって？

Ç€Ç - 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バイト

単語の配列を取り、出力します。

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

テスト

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

文字列バージョン、112バイト

文字列を取り、出力します。

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)

テスト

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バイト

コードの74バイト+ -0paフラグ用の3バイト。

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

オンラインでお試しください！

私が「盗んだ」古い@Ton Hospelの投稿のおかげで8バイトを節約しましたs/../chop/reg。（以前に持っていた$c=y///c/2,s/.{$c}$//）

Perl 6、84バイト

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

単語のリストを入力および出力します。

使い方

ラムダの内部で、別のラムダを定義して、「前後から交互に文字を取得する」ツイストを実行します。

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.

これxxは、魔法の遅延評価を提供するという点で、演算子は関数よりもマクロに近いためです。

次に、メインラムダで：

                   [$_]                          # 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バイト

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

これは上記のバリエーションで、異なる空白文字を保持しながら文字列を入出力します。

Haskell、115 95 93 98 95バイト

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

で呼び出し(!)=<<(f=<<).f.words $ "some string"ます。オンラインでお試しください！

先ほどチャレンジを誤解していたことを指摘してくれた@nimiに感謝します。

この関数fはリストに対してツイストを実行するため、文字列（文字のリスト）および文字列のリストに対して使用できます。 a!bstringの空白をstring bに挿入しますa。

(!)=<<(f=<<).f.wordsと同等\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"