문자열을 감안할 때 l, 모든 상동 문자열 찾기 p의 l(를 포함하여 중복 및 단일 문자열을). 그런 다음 모든 하위 문자열을 p유효한 회문으로 다시 정렬하십시오 (여러 정답이있을 수 있음). p단일 회문 으로 재 배열 할 수없는 경우 프로그램에 정의되지 않은 동작 (오류, 스택 오버플로, 종료, John Dvorak의 중단 / 때때하지 않은 살인 등)이있을 수 있습니다.

예

유효한 테스트 사례

l = anaa
p = ['a', 'n', 'a', 'a', 'aa', 'ana']
result = anaaaaana or aanaaanaa or aaananaaa

l = 1213235
p = ['1', '2', '1', '3', '2', '3', '5', '121', '323']
result = 1213235323121

l = racecar
p = ['r', 'a', 'c', 'e', 'c', 'a', 'r', 'cec', 'aceca', 'racecar']
result = racecarcecaacecracecar (there are others)

l = 11233
p = ['1', '11', '1', '2', '3', '33', '3']
result = 113323311 or 331121133

l = abbccdd
p = ['a', 'b', 'bb', 'b', 'c', 'cc', 'c', 'd', 'dd', 'd']
result = bbccddaddccbb or ccbbddaddbbcc or (etc...)

l = a
p = ['a']
result = a

잘못된 테스트 사례 (불가능)

l = 123456789
p = ['1', '2', '3', '4', '5', '6', '7', '8', '9']
result = <not possible, behavior undefined>

l = hjjkl
p = ['h', 'j', 'jj', 'j', 'k', 'l']
result = <not possible, behavior undefined>

l = xjmjj
p = ['x', 'j', 'jmj', 'm', 'j', 'jj', 'j']
result = <not possible, behavior undefined>

규칙

• 입력 단어가 회문 자체 인 경우 항상 입력으로 유효합니다.
• 하나의 하위 문자열 만 반환해야합니다. 선택한 하위 문자열 중 하나만 유효합니다.
• 입력에 실행 가능한 출력이 없으면 코드에 정의되지 않은 동작이있을 수 있습니다.
• 입력은 사이에 ASCII 인쇄 가능 문자 만 포함합니다 0x20-0x7E.
• 이것은 code-golf 이며, 가장 낮은 바이트 수가 승자입니다.

Brachylog , 10 바이트

{s.↔}ᶠpc.↔

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

false.가능하지 않으면 실패합니다 (예 : 인쇄 ).

설명

{   }ᶠ         Find all…
 s.              …substrings of the input…
  .↔             …which are their own reverse
      p        Take a permutation of this list of palindromes
       c.      The output is the concatenation of this permutation
        .↔     The output is its own reverse

코코넛 , 140 바이트

s->p(map(''.join,permutations(p(v for k in n(s)for v in n(k[::-1])))))[0]
from itertools import*
n=scan$((+))
p=list..filter$(x->x==x[::-1])

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

자바 스크립트 (ES6), 193 바이트

"봐, 내장 순열 없음!" (그래서 ... 긴 ...)

솔루션이 없으면 빈 배열을 반환합니다.

f=(s,a=[].concat(...[...s].map((_,i,a)=>a.map((_,j)=>s.slice(i,j+1)))).filter(P=s=>[...s].reverse().join``==s&&s),m=S=[])=>S=a.map((_,i)=>f(s,b=[...a],[...m,b.splice(i,1)]))>''?S:P(m.join``)||S

데모

f=(s,a=[].concat(...[...s].map((_,i,a)=>a.map((_,j)=>s.slice(i,j+1)))).filter(P=s=>[...s].reverse().join``==s&&s),m=S=[])=>S=a.map((_,i)=>f(s,b=[...a],[...m,b.splice(i,1)]))>''?S:P(m.join``)||S

console.log(f('anaa'))
console.log(f('1213235'))
console.log(f('hjjkl'))
console.log(f('a'))

어떻게?

코드를 더 작은 부분으로 나누겠습니다.

우리는 정의 () P를 , 함수가 반환 의 경우 의가 회문, 또는 거짓 그렇지.

P = s => [...s].reverse().join`` == s && s

입력 문자열 s의 모든 하위 문자열을 계산합니다 . P ()를 사용하여 비어 있지 않은 회문을 분리하여 배열 a 에 저장합니다 .

a = [].concat(...[...s].map((_, i, a) => a.map((_, j) => s.slice(i, j + 1)))).filter(P)

주요 재귀 함수 F ()이 얻어 를 입력으로하고 모든 순열을 계산한다. 순열 자체가 회문 (한 번 결합) 일 때마다 S를 업데이트 하고 결국 S 의 최종 값을 반환합니다 .

f = (                        // given:
  a,                         //   a[] = input array
  m = S = []                 //   m[] = current permutation of a[]
) =>                         //   and S initialized to []
  S = a.map((_, i) =>        // for each element at position i in a[]:
    f(                       //   do a recursive call with:
      b = [...a],            //     b[] = copy of a[] without the i-th element
      [...m, b.splice(i, 1)] //     the element extracted from a[] added to m[]
    )                        //   end of recursive call
  ) > '' ?                   // if a[] was not empty:
    S                        //   let S unchanged
  :                          // else:
    P(m.join``) || S         //   update S to m.join('') if it's a palindrome

젤리 , 13 바이트

ŒḂÐf
ẆÇŒ!F€ÇḢ

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

0유효하지 않은 경우에 인쇄 합니다.

05AB1E , 13 12 바이트

ŒʒÂQ}œJʒÂQ}¤

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

Magic Octopus Urn 및 Enigma 덕분에 -1 바이트.

Stax , 13 바이트

绬►Ö∞j∞:Æ╘τδ

테스트 사례 실행 (현재 컴퓨터에서 약 10 초 소요)

이것은 동일한 프로그램의 해당 ASCII 표현입니다.

:e{cr=fw|Nc$cr=!

그것은 순수한 무차별 대입은 아니지만 내가 작성한 무차별 대입 구현만큼 작습니다. 약 10 분 후에 브라우저가 다운되었습니다. 어쨌든, 작동 방식은 다음과 같습니다.

:e                  Get all contiguous substrings
  {cr=f             Keep only those that are palindromes
       w            Run the rest of the program repeatedly while a truth value is produced.
        |N          Get the next permutation.
          c$        Copy and flatten the permutation.
            cr=!    Test if it's palindrome.  If not, repeat.
                    The last permutation produced will be implicitly printed.

루비 , 131 (123) 120 바이트

->s{m=->t{t==t.reverse}
(1..z=s.size).flat_map{|l|(0..z-l).map{|i|s[i,l]}}.select(&m).permutation.map(&:join).detect &m}

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

문자열을 수락하고 문자열을 반환하는 람다. nil솔루션이 없을 때 반환 합니다.

-5 바이트 : 바꾸기 select{|t|l[t]}로select(&l)

-3 바이트 : 바꾸기 map{..}.flatten로flat_map{...}

-1 바이트 : 부분 문자열 시작 및 부분 문자열 끝 대신 부분 문자열 길이 및 부분 문자열 시작에 대한 루프

-2 바이트 : z사전 사용 대신 처음 사용시 선언

->s{
  l=->t{t==t.reverse}        # Lambda to test for palindromes
  (1..z=s.size).flat_map{|l| # For each substring length
    (0..z-l).map{|i|         # For each substring start index
      s[i,l]                 # Take the substring
    }
  }                          # flat_map flattens the list of lists of substrings
  .select(&l)                # Filter to include only palindromic substrings
  .permutation               # Take all orderings of substrings
  .map(&:join)               # Flatten each substring ordering into a string
  .detect &l                 # Find the first palindrome
}

Pyth , 13 바이트

h_I#sM.p_I#.:

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

Mr. Xcoder 덕분에 -1 바이트

파이썬 3 , 167 바이트

lambda a:g(sum(k,[])for k in permutations(g(a[i:j+1]for i in range(len(a))for j in range(i,len(a)))))[0]
g=lambda k:[e for e in k if e==e[::-1]]
from itertools import*

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

Mr. Xcoder 덕분에 -2 바이트

apt , 19 바이트

Japt가 방해받지 못했지만 (아직) 모든 것을 얻을 수 없었습니다. 문자열의 하위 문자열 그리고 부분적으로 현재의 고갈 수준에 의해 .

undefined솔루션이 없으면 출력 합니다.

Êõ@ãX fêQÃc á m¬æêQ

시도 해봐

설명

                        :Implicit input of string U
Ê                       :Length of U
 õ                      :Range [1,Ê]
  @      Ã              :Pass each X through a function
   ãX                   :  Substrings of U of length X
      f                 :  Filter
       êQ               :    Is it a palindrome?
          c             :Flatten
            á           :Permutations
              m         :Map
               ¬        :  Join to a string
                æêQ     :Get first element that is a palindrome

껍질 , 12 바이트

ḟS=↔mΣPfS=↔Q

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

설명

ḟS=↔mΣPfS=↔Q  Implicit input, a string.
           Q  List of substrings.
       f      Keep those
        S=↔   that are palindromic (equal to their reversal).
      P       Permutations of this list.
    mΣ        Flatten each.
ḟ             Find an element
 S=↔          that is palindromic.

J , 53 바이트

[:{:@(#~b"1)@(i.@!@#;@A.])@(#~(0<#*b=.]-:|.)&>)@,<\\.

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