规则

该程序应接收一个字符串/单词数组作为输入。对于字符串/数组中的每个单词，它将通过从单词的正面和背面以交替方式获取字符来重建单词。

12345 678 9-> 15243 687 9。

然后，它将以字符串中最早出现的单词和最新出现的单词之间交替的方式重新排列单词。

15243 687 9-> 15243 9 687

最后，它将通过在输出结果之前将空格，制表符和换行符放置在它们最初所在的索引处来重建字符串。

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

输出应与输入具有相同的数据类型。

禁止标准漏洞

例子

输入：
敏捷的棕色狐狸跳过了懒狗。
输出：
Teh d.ogq kucil yaz bnrwo tehf xoo rvej supm

输入：
敏捷的棕色狐狸跳过
了懒狗。
输出：
Teh d.ogq kucil yaz bnrwo
tehf xoo rvej supm

输入：
Aflack
输出：
Akfcla

这是代码高尔夫球，所以最短的代码胜出

果冻，15 14  8 字节

甲高达 6字节从保存丹尼斯（通过移动内部链接1扁平化和模具没有必要分成两个头，和扁平化是存在已使他们成为一个！）

żṚFṁ
Ç€Ç

（从两行： żṚ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个字节的代码+ 3个字节的-0pa标志。

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

在线尝试！

保存的8字节感谢老@Ton Hospel的岗位，我‘偷’ s/../chop/reg。（我以前有$c=y///c/2,s/.{$c}$//）

Perl 6，84个字节

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

输入和输出单词列表。

怎么运行的

在lambda内，我定义了另一个lambda来执行“ 从正面和背面以交替方式获取字符 ”扭曲：

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可行，是运算符更像是宏而不是函数，因为它提供了神奇的惰性求值。

然后在主lambda中：

                   [$_]                          # 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!b将string的空白b插入string中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"