กฎระเบียบ

โปรแกรมควรรับสตริง / อาร์เรย์ของคำเป็นอินพุต สำหรับแต่ละคำในสตริง / อาเรย์มันจะสร้างคำใหม่โดยการใช้ตัวอักษรในการสลับแฟชั่นจากด้านหน้าและด้านหลังของคำ

12345 678 9 -> 15243 687 9

จากนั้นจะจัดเรียงคำใหม่ในลักษณะสลับระหว่างคำแรกสุดและคำที่เกิดขึ้นล่าสุดในสตริง

15243 687 9 -> 15243 9 687

ในที่สุดมันจะสร้างสตริงขึ้นใหม่โดยการวางช่องว่างแท็บและการขึ้นบรรทัดใหม่ที่ดัชนีซึ่งเป็นตำแหน่งเริ่มต้นก่อนที่จะแสดงผลลัพธ์

12345 678 9-> 15243 687 9 -> 15243 9 687 -> 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}

อินพุตและเอาต์พุตรายการคำ

มันทำงานอย่างไร

ภายในแลมบ์ดาฉันได้กำหนดแลมบ์ดาอีกหนึ่งตัวเพื่อทำการ"บิดตัวละครในแฟชั่นสลับจากด้านหน้าและด้านหลัง " การบิด:

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 bytes

{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แทรกช่องว่างของสตริงเป็นสตริงba

(!)=<<(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"