Dada uma sequência l, encontre todas as substrings palindrômicas pde l(incluindo duplicatas e cadeias de caracteres únicos). Em seguida, reorganize todas as sub-strings em pum palíndromo válido (pode haver várias respostas corretas). Se não for possível reorganizar pem um único palíndromo, seu programa poderá ter um comportamento indefinido (erro, estouro de pilha, saída, suspensão / assassinato prematuro de John Dvorak, etc ...)

Exemplos

Casos de teste 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 teste inválidos (não é possível)

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>

Regras

• Se a palavra de entrada for um palíndromo, ela sempre será válida como entrada.
• Somente uma substring deve ser retornada, e a que você escolher é arbitrária, desde que válida.
• Se a entrada não tiver saída viável, seu código pode ter um comportamento indefinido.
• As entradas conterão apenas caracteres imprimíveis ASCII entre 0x20-0x7E.
• Este é o código-golfe , o menor número de bytes é o vencedor.

Braquilog , 10 bytes

{s.↔}ᶠpc.↔

Experimente online!

Falha (isto é, impressões false.), se não for possível.

Explicação

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

Experimente online!

JavaScript (ES6), 193 bytes

"Olha, mãe, sem permutação embutida!" (Então sim ... é longo ...)

Retorna uma matriz vazia se não houver solução.

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

Quão?

Vamos dividir o código em partes menores.

Definimos P () , uma função que retorna s se s é um palíndromo ou falso, caso contrário.

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

Computamos todas as substrings da string de entrada s . Usando P () , isolamos os palíndromos não vazios e os armazenamos na matriz a .

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

A principal função recursiva f () pega a como entrada e calcula todas as suas permutações. Ele atualiza S sempre que o próprio permutação é um palíndromo (uma vez juntou-se), e, eventualmente, retorna o 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

Gelatina , 13 bytes

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

Experimente online!

Imprime 0no caso inválido.

05AB1E , 13 12 bytes

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

Experimente online!

-1 byte graças ao Magic Octopus Urn e Enigma.

Stax , 13 bytes

绬►Ö∞j∞:Æ╘τδ

Executar casos de teste (leva cerca de 10 segundos na minha máquina atual)

Esta é a representação ascii correspondente do mesmo programa.

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

Não é força bruta pura , mas é tão pequena quanto a implementação de força bruta que escrevi. Aquele travou meu navegador após cerca de 10 minutos. Enfim, aqui está 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.

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

Experimente online!

Um lambda aceitando uma sequência e retornando uma sequência. Retorna nilquando não existe solução.

-5 bytes: substitua select{|t|l[t]}porselect(&l)

-3 bytes: Substitua map{..}.flattenporflat_map{...}

-1 bytes: loop sobre o comprimento da substring e o início da substring, em vez de sobre o início e o final da substring

-2 bytes: declarar zno primeiro uso em vez 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
}

Pitão , 13 bytes

h_I#sM.p_I#.:

Experimente online!

-1 byte graças ao 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*

Experimente online!

-2 bytes graças ao Sr. Xcoder

Japonês , 19 bytes

Impedido por Japt não (ainda) ser capaz de obter todos os substrings de uma string (e em parte pelos meus níveis atuais de exaustão!).

Saídas undefinedse não houver solução.

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

Tente

Explicação

                        :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

Casca , 12 bytes

ḟS=↔mΣPfS=↔Q

Experimente online!

Explicação

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

Experimente online!