Quy tắc

Chương trình sẽ nhận được một chuỗi / mảng các từ làm đầu vào. Đối với mỗi từ trong chuỗi / mảng, nó sẽ tái tạo lại từ đó bằng cách lấy các ký tự theo kiểu xen kẽ từ mặt trước và mặt sau của từ.

12345 678 9 -> 15243 687 9.

Sau đó, nó sẽ sắp xếp lại các từ theo cách xen kẽ giữa từ xuất hiện sớm nhất và mới nhất trong chuỗi.

15243 687 9 -> 15243 9 687

Cuối cùng, nó sẽ xây dựng lại chuỗi bằng cách đặt khoảng trắng, tab và dòng mới vào các chỉ mục nơi chúng được đặt ban đầu trước khi xuất kết quả.

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

Đầu ra phải là kiểu dữ liệu giống như đầu vào.

Lỗ hổng tiêu chuẩn bị cấm

Ví dụ

Đầu vào:
Con cáo nâu nhanh nhẹn nhảy qua con chó lười.
Đầu ra:
Te d.ogq kucil yaz bnrwo tehf xoo rvej supm

Đầu vào:
Con cáo nâu nhanh nhẹn nhảy
qua con chó lười.
Đầu ra:
Te d.ogq kucil yaz
bnrwo tehf xoo rvej supm

Đầu vào:
Aflack
Đầu ra:
Akfcla

Đây là môn đánh gôn nên mã ngắn nhất sẽ thắng

Thạch , 15 14  8 byte

Một con số khổng lồ 6 byte tiết kiệm từ Dennis (bằng cách di chuyển flatten và nấm mốc bên trong liên kết 1 không có cần phải chia thành hai và người đứng đầu, và một flatten là đã có để họ trở thành một!)

żṚFṁ
Ç€Ç

(từ hai dòng: żṚFœs2Ḣvà Ç€ÇFṁ⁸)

Hãy thử trực tuyến!

Lấy một mảng các từ và trả về một mảng các từ mới. (Footer tại TIO gọi điều này và nối các mảng với khoảng trắng để nó in ra độc đáo.)

Lưu ý - xử lý một chuỗi đơn, tách trên các không gian tab và dòng mới, sau đó tập hợp lại thực sự tỏ ra khá khó khăn; một khi tôi thấy rằng một danh sách các từ là một lựa chọn thì mọi thứ trở nên dễ dàng hơn nhiều!

Làm sao?

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

Đưa và xuất ra một loạt các từ.

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

Kiểm tra

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

Phiên bản chuỗi, 112 byte

Đưa và xuất ra một chuỗi.

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)

Kiểm tra

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 mã + 3 byte cho -0pa cờ.

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

Hãy thử trực tuyến!

Saved 8 byte nhờ một tuổi @Ton Hospel 's bài nơi tôi 'lấy trộm' s/../chop/reg. (Trước đây tôi đã có $c=y///c/2,s/.{$c}$//)

Perl 6 , 84 byte

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

Đầu vào và đầu ra một danh sách các từ.

Làm thế nào nó hoạt động

Bên trong lambda, tôi đã định nghĩa một lambda khác để thực hiện "xoắn các nhân vật theo kiểu xen kẽ từ trước và sau ":

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.

Điều này hoạt động vì xxtoán tử giống như một macro hơn là một hàm, trong đó nó cung cấp đánh giá lười biếng ma thuật.

Sau đó trong lambda chính:

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

Đây là một biến thể của ở trên, đầu vào và đầu ra một chuỗi - bảo tồn các ký tự khoảng trắng khác nhau.

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

Gọi với (!)=<<(f=<<).f.words $ "some string".Hãy thử trực tuyến!

Cảm ơn @nimi đã chỉ ra rằng tôi đã đọc sai thử thách trước đó.

Hàm fthực hiện xoắn trên một danh sách, vì vậy nó có thể được sử dụng trên các chuỗi (danh sách ký tự) và danh sách các chuỗi. a!bchèn khoảng trắng của chuỗi bvào chuỗi a.

(!)=<<(f=<<).f.wordstương đương với \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"