Aturan

Program harus menerima string / array kata sebagai input. Untuk setiap kata dalam string / array, itu akan merekonstruksi kata dengan mengambil karakter secara bergantian dari depan dan belakang kata.

12345 678 9 -> 15243 687 9.

Kemudian akan mengatur ulang kata-kata dengan cara bergantian antara kata yang paling awal dan yang terjadi terakhir dalam string.

15243 687 9 -> 15243 9 687

Akhirnya, itu akan merekonstruksi string dengan menempatkan spasi, tab dan baris baru pada indeks di mana mereka awalnya berada sebelum mengeluarkan hasilnya.

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

Keluaran harus datatype yang sama dengan input.

Celah Standar dilarang

Contohnya

Input:
Rubah cokelat cepat melompati anjing malas.
Keluaran:
Teh d.ogq kucil yaz bnrwo tehf xoo rvej supm

Input:
Rubah cokelat cepat melompati
anjing malas.
Keluaran:
Teh d.ogq kucil yaz bnrwo
tehf xoo rvej supm

Input:
Aflack
Output:
Akfcla

Ini adalah kode-golf sehingga kode terpendek menang

Jelly , 15 14  8 byte

Sebuah kekalahan 6 byte menyelamatkan dari Dennis (dengan memindahkan meratakan dan cetakan dalam link 1 tidak ada perlu dibagi menjadi dua dan kepala, dan meratakan adalah sudah ada sehingga mereka menjadi salah satu!)

żṚFṁ
Ç€Ç

(dari dua baris:, żṚFœs2Ḣdan Ç€ÇFṁ⁸)

Cobalah online!

Mengambil larik kata-kata dan mengembalikan larik kata-kata baru. (Footer at TIO memanggil ini dan bergabung dengan array dengan spasi sehingga tercetak dengan baik.)

Catatan - menangani string tunggal, membelah ruang tab dan baris baru, kemudian memasang kembali sebenarnya terbukti agak rumit; begitu saya melihat daftar kata-kata adalah pilihan, banyak hal menjadi lebih mudah!

Bagaimana?

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

Membawa dan menampilkan berbagai kata.

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

Uji

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

Versi string, 112 byte

Mengambil dan mengeluarkan string.

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)

Uji

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 kode + 3 byte untuk -0paflag.

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

Cobalah online!

Disimpan 8 byte berkat tua @Ton Hospel 's posting di mana aku 'mencuri' s/../chop/reg. (Sebelumnya saya punya $c=y///c/2,s/.{$c}$//)

Perl 6 , 84 byte

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

Input dan output daftar kata-kata.

Bagaimana itu bekerja

Di dalam lambda, saya mendefinisikan lambda lain untuk melakukan " memutar mengambil karakter secara bergantian dari depan dan belakang ":

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.

Ini berfungsi karena xxoperator lebih seperti makro daripada fungsi, karena memberikan evaluasi malas malas.

Kemudian di lambda utama:

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

Ini adalah variasi di atas, yang menginput dan mengeluarkan string - mempertahankan karakter spasi putih yang berbeda.

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

Panggil dengan (!)=<<(f=<<).f.words $ "some string".Cobalah online!

Terima kasih kepada @nimi karena telah menunjukkan bahwa saya salah membaca tantangan sebelumnya.

Fungsi fmelakukan memutar pada daftar, sehingga dapat digunakan pada string (daftar karakter) dan daftar string. a!bmenyisipkan spasi putih dari string bke string a.

(!)=<<(f=<<).f.wordssetara dengan \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"