규칙

프로그램은 입력으로 문자열 / 배열을 받아야합니다. 문자열 / 배열의 각 단어에 대해 단어의 앞뒤에서 문자를 번갈아 가면서 단어를 재구성합니다.

12345678 9-> 15243 687 9.

그런 다음 문자열에서 가장 빨리 나오는 단어와 가장 최근에 나오는 단어 사이에서 단어를 번갈아 다시 배열합니다.

15243 687 9-> 15243 9 687

마지막으로, 결과를 출력하기 전에 공백, 탭 및 줄 바꿈을 처음에 찾은 인덱스에 배치하여 문자열을 재구성합니다.

12345678 9-> 15243 687 9-> 15243 9 687-> 15243968 7

출력은 입력과 동일한 데이터 유형이어야합니다.

표준 허점 은 금지되어 있습니다

예

입력 :
빠른 갈색 여우가 게으른 개 위로 뛰어 넘습니다.
출력 :
Teh d.ogq kucil yaz bnrwo tehf xoo rvej supm

입력 :
빠른 갈색 여우가
게으른 개 위로 뛰어 넘습니다.
출력 :
Teh d.ogq kucil yaz
bnrwo tehf xoo rvej supm

입력 :
부족
출력 :
Akfcla

이것은 코드 골프 이므로 가장 짧은 코드가 승리합니다.

젤리 , 15 14  8 바이트

무려 선방 6 바이트 데니스 (두 가지 및 헤드로 분할 할 필요는없고, 그들은 하나가되도록 패턴 화 된 이미 존재 링크 1 내부 평평 주형을 이동시킴으로써!)

żṚFṁ
Ç€Ç

(두 줄에서 : żṚFœs2Ḣ및 Ç€ÇFṁ⁸)

온라인으로 사용해보십시오!

단어 배열을 가져 와서 새 단어 배열을 반환합니다. TIO의 Footer는 이것을 호출하고 공백으로 배열을 조인하므로 멋지게 인쇄합니다.

참고-단일 문자열을 처리하고 탭 공간과 줄 바꿈을 분할 한 다음 다시 어셈블하는 것이 실제로 까다로운 것으로 입증되었습니다. 일단 단어 목록이 옵션이라는 것을 알았을 때 일이 훨씬 쉬워졌습니다!

어떻게?

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

자바 스크립트 (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}$//)

펄 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.

펄 6 , 87 바이트

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

이것은 다른 공백 문자를 유지하면서 문자열을 입력 및 출력하는 위의 변형입니다.

하스켈 , 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"