Dada una cadena l, encuentre todas las subcadenas palindrómicas pde l(incluidas las cadenas duplicadas y de un solo carácter). A continuación, reorganice todas las subcadenas en pun palíndromo válido (puede haber múltiples respuestas correctas). Si no es posible reorganizar pen un solo palíndromo, su programa puede tener un comportamiento indefinido (error, desbordamiento de pila, salir, colgar / asesinato prematuro de John Dvorak, etc.)

Ejemplos

Casos de prueba válidos

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

Casos de prueba inválidos (no es posible)

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>

Reglas

• Si la palabra de entrada es un palíndromo, siempre será válida como entrada.
• Solo debe devolverse una subcadena, la que elija es arbitraria siempre que sea válida.
• Si la entrada no tiene salida viable, su código puede tener un comportamiento indefinido.
• Las entradas solo contendrán caracteres imprimibles en ASCII entre 0x20-0x7E.
• Este es el código de golf , el conteo de bytes más bajo es el ganador.

Brachylog , 10 bytes

{s.↔}ᶠpc.↔

Pruébalo en línea!

Falla (es decir, impresiones false.) si no es posible.

Explicación

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

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

Pruébalo en línea!

JavaScript (ES6), 193 bytes

"¡Mira mamá, no hay permutación incorporada!" (Entonces sí ... es largo ...)

Devuelve una matriz vacía si no hay solución.

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

Manifestación

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

¿Cómo?

Dividamos el código en partes más pequeñas.

Definimos P () , una función que devuelve s si s es un palíndromo, o falso de lo contrario.

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

Calculamos todas las subcadenas de la cadena de entrada s . Usando P () , aislamos los palíndromos no vacíos y los almacenamos en la matriz a .

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

La función recursiva principal f () toma una entrada y calcula todas sus permutaciones. En él se actualiza S cada vez que la permutación en sí es un palíndromo (una vez unido), y, finalmente, devuelve el valor final de 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

Jalea , 13 bytes

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

Pruébalo en línea!

Imprime 0en el caso inválido.

05AB1E , 13 12 bytes

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

Pruébalo en línea!

-1 byte gracias a Magic Octopus Urn y Enigma.

Stax , 13 bytes

绬►Ö∞j∞:Æ╘τδ

Ejecutar casos de prueba (toma alrededor de 10 segundos en mi máquina actual)

Esta es la representación ascii correspondiente del mismo programa.

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

No es pura fuerza bruta, pero es tan pequeña como la implementación de fuerza bruta que escribí. Ese bloqueó mi navegador después de unos 10 minutos. De todos modos, así es como funciona.

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

Rubí , 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}

Pruébalo en línea!

Una lambda que acepta una cadena y devuelve una cadena. Devuelve nilcuando no existe una solución.

-5 bytes: reemplazar select{|t|l[t]} conselect(&l)

-3 bytes: reemplazar map{..}.flatten conflat_map{...}

-1 bytes: bucle sobre la longitud de la subcadena y el inicio de la subcadena, en lugar de sobre el inicio y el final de la subcadena

-2 bytes: declarar zal primer uso en lugar de antes

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

Pruébalo en línea!

-1 byte gracias al Sr. 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*

Pruébalo en línea!

-2 bytes gracias al Sr. Xcoder

Japt , 19 bytes

Impulsado por Japt que (todavía) no puede obtener todas las subcadenas de una cadena (¡y en parte por mis niveles actuales de agotamiento!).

Salidas undefinedsi no hay solución.

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

Intentalo

Explicación

                        :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

Casco , 12 bytes

ḟS=↔mΣPfS=↔Q

Pruébalo en línea!

Explicación

ḟ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=.]-:|.)&>)@,<\\.

Pruébalo en línea!