Đưa ra một chuỗi l, tìm tất cả các chuỗi con palindromic pcủa l(bao gồm các chuỗi trùng lặp và chuỗi ký tự đơn). Tiếp theo, sắp xếp lại tất cả các chuỗi con pthành một bảng màu hợp lệ (có thể có nhiều câu trả lời đúng). Nếu không thể sắp xếp lại pthành một bảng màu, chương trình của bạn có thể có hành vi không xác định (lỗi, tràn ngăn xếp, thoát, treo / giết không kịp thời của John Dvorak, v.v.)

Ví dụ

Các trường hợp kiểm tra hợp lệ

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

Các trường hợp kiểm tra không hợp lệ (Không thể)

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>

Quy tắc

• Nếu từ đầu vào là một bảng màu, nó sẽ luôn có giá trị như đầu vào.
• Chỉ nên trả về một chuỗi con, chuỗi nào bạn chọn là tùy ý miễn là hợp lệ.
• Nếu đầu vào không có đầu ra khả thi, mã của bạn có thể có hành vi không xác định.
• Các đầu vào sẽ chỉ chứa các ký tự có thể in ASCII giữa 0x20-0x7E.
• Đây là mã golf , số byte thấp nhất là người chiến thắng.

Brachylog , 10 byte

{s.↔}ᶠpc.↔

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

Thất bại (tức là in false.) nếu không thể.

Giải trình

{   }ᶠ         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

Dừa , 140 byte

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])

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

JavaScript (ES6), 193 byte

"Nhìn Ma, không có hoán vị tích hợp!" (Vì vậy, vâng ... nó dài ...)

Trả về một mảng trống nếu không có giải pháp.

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

Bản giới thiệu

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'))

Làm sao?

Hãy chia mã thành các phần nhỏ hơn.

Chúng tôi định nghĩa P () , một hàm trả về s nếu s là một palindrom hoặc sai khác.

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

Chúng tôi tính toán tất cả các chuỗi con của chuỗi đầu vào s . Sử dụng P () , chúng tôi cô lập các palindromes không trống và lưu trữ chúng trong mảng a .

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

Các chính đệ quy hàm f () mất một như là đầu vào và tính toán tất cả các hoán vị của nó. Nó cập nhật S bất cứ khi nào hoán vị chính nó là một palindrome (một lần tham gia), và cuối cùng trả về giá trị cuối cùng của 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

Thạch , 13 byte

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

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

In 0trong trường hợp không hợp lệ.

05AB1E , 13 12 byte

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

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

-1 byte nhờ Magic Octopus Urn và Enigma.

Stax , 13 byte

绬►Ö∞j∞:Æ╘τδ

Chạy các trường hợp thử nghiệm (Mất khoảng 10 giây trên máy hiện tại của tôi)

Đây là đại diện ascii tương ứng của cùng một chương trình.

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

Nó không hoàn toàn là vũ phu, nhưng nó chỉ nhỏ như việc thực hiện vũ phu mà tôi đã viết. Cái đó đã làm sập trình duyệt của tôi sau khoảng 10 phút. Dù sao, đây là cách nó hoạt động.

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

Ruby , 131 123 120 byte

->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}

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

Một lambda chấp nhận một chuỗi và trả lại một chuỗi. Trả về nilkhi không có giải pháp tồn tại.

-5 byte: Thay thế select{|t|l[t]}bằngselect(&l)

-3 byte: Thay thế map{..}.flattenbằngflat_map{...}

-1 byte: Lặp lại chiều dài chuỗi con và bắt đầu chuỗi con, thay vì bắt đầu chuỗi con và kết thúc chuỗi con

-2 byte: Khai báo zlần đầu sử dụng thay vì trước

->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
}

Bình thường , 13 byte

h_I#sM.p_I#.:

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

-1 byte nhờ ông Xcoder

Python 3 , 167 byte

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*

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

-2 byte nhờ ông Xcoder

Japt , 19 byte

Bị cản trở bởi Japt không (chưa) có thể có được tất cả các chuỗi con (và một phần bởi mức độ kiệt sức hiện tại của tôi!).

Đầu ra undefinednếu không có giải pháp.

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

Thử nó

Giải trình

                        :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

Husk , 12 byte

ḟS=↔mΣPfS=↔Q

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

Giải trình

ḟ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 byte

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

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