lSuchen Sie bei gegebener Zeichenfolge alle palindromischen Teilzeichenfolgen pvon l(einschließlich Duplikaten und Einzelzeichenfolgen). Ordnen Sie anschließend alle Unterzeichenfolgen pin einem gültigen Palindrom neu an (möglicherweise gibt es mehrere richtige Antworten). Wenn es nicht möglich ist, pin ein einzelnes Palindrom umzuordnen, weist Ihr Programm möglicherweise ein undefiniertes Verhalten auf (Fehler, Stapelüberlauf, Beenden, Hängen / vorzeitiger Mord an John Dvorak usw.).

Beispiele

Gültige Testfälle

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

Ungültige Testfälle (nicht möglich)

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>

Regeln

• Wenn das Eingabewort selbst ein Palindrom ist, ist es immer als Eingabe gültig.
• Es sollte nur ein Teilstring zurückgegeben werden, der beliebig ist, solange er gültig ist.
• Wenn die Eingabe keine brauchbare Ausgabe enthält, weist Ihr Code möglicherweise ein undefiniertes Verhalten auf.
• Eingaben enthalten nur ASCII-druckbare Zeichen zwischen 0x20-0x7E.
• Das ist Code-Golf , die niedrigste Byteanzahl ist der Gewinner.

Brachylog , 10 Bytes

{s.↔}ᶠpc.↔

Probieren Sie es online!

Schlägt fehl (dh druckt false.), wenn nicht möglich.

Erläuterung

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

Kokosnuss , 140 Bytes

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

Probieren Sie es online!

JavaScript (ES6), 193 Byte

"Schau Ma, keine Permutation eingebaut!" (Also ja ... es ist lang ...)

Gibt ein leeres Array zurück, wenn es keine Lösung gibt.

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

Demo

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

Wie?

Teilen wir den Code in kleinere Teile auf.

Wir definieren P () , eine Funktion, die s zurückgibt, wenn s ein Palindrom ist, oder andernfalls false .

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

Wir berechnen alle Teilzeichenfolgen der Eingabezeichenfolge s . Mit P () isolieren wir die nicht leeren Palindrome und speichern sie im Array a .

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

Die rekursive Hauptfunktion f () nimmt a als Eingabe und berechnet alle ihre Permutationen. Es aktualisiert S, wenn die Permutation selbst ein Palindrom ist (einmal verbunden) und gibt schließlich den Endwert von S zurück .

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

Gelee , 13 Bytes

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

Probieren Sie es online!

Druckt 0im ungültigen Fall.

05AB1E , 13 12 Bytes

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

Probieren Sie es online!

-1 Byte dank Magic Octopus Urn und Enigma.

Stax , 13 Bytes

绬►Ö∞j∞:Æ╘τδ

Testfälle ausführen (Auf meinem aktuellen Computer dauert es ungefähr 10 Sekunden.)

Dies ist die entsprechende ASCII-Darstellung desselben Programms.

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

Es ist nicht ganz reine Brute-Force, aber es ist genauso klein wie die Brute-Force-Implementierung, die ich geschrieben habe. Dieser stürzte meinen Browser nach ca. 10 Minuten ab. Wie auch immer, hier ist, wie es funktioniert.

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

Rubin , 131 123 120 Bytes

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

Probieren Sie es online!

Ein Lambda, das eine Zeichenfolge akzeptiert und eine Zeichenfolge zurückgibt. Gibt zurück, nilwenn keine Lösung vorhanden ist.

-5 Bytes: Ersetzen select{|t|l[t]}durchselect(&l)

-3 Bytes: Ersetzen map{..}.flattendurchflat_map{...}

-1 Bytes: Schleife über Länge und Ende des Teilstrings anstatt über Anfang und Ende des Teilstrings

-2 Bytes: zBei der ersten Verwendung anstelle von vorher deklarieren

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

h_I#sM.p_I#.:

Probieren Sie es online!

-1 Byte danke an Herrn Xcoder

Python 3 , 167 Bytes

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*

Probieren Sie es online!

-2 Bytes dank Mr. Xcoder

Japt , 19 Bytes

Behindert durch Japt (noch) nicht alle Teilstrings eines Strings bekommen zu können (und teilweise durch meine momentane Erschöpfung!).

Gibt aus, undefinedwenn es keine Lösung gibt.

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

Versuch es

Erläuterung

                        :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

Schale , 12 Bytes

ḟS=↔mΣPfS=↔Q

Probieren Sie es online!

Erläuterung

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

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

Probieren Sie es online!