Bir dize göz önüne alındığında l, tüm palindromic dizeleri bulup parasında l(dahil kopyaların ve tek karakter dizeleri). Ardından, tüm alt dizeleri pgeçerli bir palindromda yeniden düzenleyin (birden fazla doğru yanıt olabilir). pTek bir palindromda yeniden düzenleme yapmak mümkün değilse , programınızın tanımlanmamış davranışı olabilir (hata, yığın taşması, çıkma, John Dvorak'ın askıya alınması / zamansız öldürülmesi, vb.)

Örnekler

Geçerli Test Durumları

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

Geçersiz Test Durumları (Mümkün değil)

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>

kurallar

• Girdi sözcüğü bir palindromsa, her zaman girdi olarak geçerli olur.
• Yalnızca bir alt dize döndürülmelidir; seçtiğiniz alt dizin geçerli olduğu sürece isteğe bağlıdır.
• Girdinin uygulanabilir bir çıktısı yoksa, kodunuz tanımlanmamış davranışa sahip olabilir.
• Girişler arasında sadece ASCII-Yazdırılabilir karakterler bulunur 0x20-0x7E.
• Bu kod golf , en düşük bayt sayımı kazanır.

Brachylog , 10 bayt

{s.↔}ᶠpc.↔

Çevrimiçi deneyin!

false.Mümkünse başarısız olur (yani yazdırır ).

açıklama

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

Hindistan cevizi , 140 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 193 bayt

"Bak anne, yerleşik permütasyon yok!" (Yani evet ... çok uzun ...)

Çözüm yoksa boş bir dizi döndürür.

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

gösteri

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

Nasıl?

Kodu daha küçük parçalara ayıralım.

Bu tanımlar () P , bir işlev donduğu s eğer s bir palindrom, ya da yanlış aksi.

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

S giriş dizesinin tüm alt dizelerini hesaplıyoruz . P () kullanarak , boş olmayan palindromları ayırır ve bunları a dizisinde saklarız .

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

Ana özyinelemeli işlev f () , bir giriş alır ve tüm permütasyonlarını hesaplar. Permütasyonun kendisi bir palindrom olduğunda (bir kez katıldığında) S'yi günceller ve sonunda S'nin son değerini döndürür .

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

Jöle , 13 bayt

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

Çevrimiçi deneyin!

0Geçersiz durumda yazdırır .

05AB1E , 13 12 bayt

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

Çevrimiçi deneyin!

Sihirli Ahtapot Urn ve Enigma sayesinde -1 bayt.

Stax , 13 bayt

绬►Ö∞j∞:Æ╘τδ

Test senaryolarını çalıştır (Mevcut makinemde yaklaşık 10 saniye sürüyor)

Bu, aynı programın ilgili ascii temsilidir.

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

Oldukça saf kaba kuvvet değil, ama yazdığım kaba kuvvet uygulaması kadar küçük. Bu, yaklaşık 10 dakika sonra tarayıcımı kilitledi. Her neyse, işte böyle.

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

Yakut , 131 123 , 120 bayt

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

Çevrimiçi deneyin!

Bir dizeyi kabul eden ve bir dizeyi döndüren lambda. nilÇözüm olmadığında geri döner.

-5 bayt: Değiştir select{|t|l[t]}ileselect(&l)

-3 bayt: Değiştir map{..}.flattenileflat_map{...}

-1 bayt: Alt dize başlatma ve alt dize sonu yerine alt dize uzunluğu ve alt dize başlangıcı üzerinden döngü

-2 bayt: zÖnceden değil, ilk kullanımda bildirin

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

h_I#sM.p_I#.:

Çevrimiçi deneyin!

Bay Xcoder sayesinde -1 bayt

Python 3 , 167 bayt

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*

Çevrimiçi deneyin!

Bay Xcoder sayesinde -2 bayt

Japt , 19 bayt

Japt tarafından (henüz) bir dizenin tüm alt dizelerini (ve kısmen mevcut tükenme seviyelerimle elde edememek) engelli .

undefinedÇözüm yoksa çıktılar .

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

Dene

açıklama

                        :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

Kabuk , 12 bayt

ḟS=↔mΣPfS=↔Q

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!