Os problemas primários palíndricos são bastante comuns, mas não é sobre isso que se trata. Nesse desafio, o número não precisa ser um palíndromo, seus principais fatores, sim.

Tarefa

Seu código deve receber um único número inteiro positivo como entrada. Em seguida, verifique se alguma das permutações dos fatores primos desse número inteiro é palíndrica quando concatenada. Nesse caso, imprima um deles (a lista de fatores, não a sequência concatenada). Senão, você deve produzir -1.

Isso é código-golfe , então o código mais curto em bytes vence!

Casos de teste

11 -> [11]
4 -> [2, 2]
39 -> [3, 13]
6 -> -1
1207 -> [17, 71]
393 -> -1
2352 -> [2, 2, 7, 3, 7, 2, 2]

05AB1E , 7 bytes

Òœ.ΔJÂQ

Experimente online!

Explicação:

Ò            # prime factorization of the input
 œ           # permutations
  .Δ         # find the first one such that
    J        # concatenated
     ÂQ      # is a palindrome

(o .Δpadrão é convenientemente -1, portanto, não é necessário trabalho extra)

Pitão, 14 bytes

-2 bytes por @FryAmTheEggman

h+f_IjkT.pPQ_1

Explicação:

h                 first element of
 +                (append a -1 to the end in case the filter is empty)
  f                 filter by lambda T:
   _I                 is invariant under reversing
     jkT              stringified list
   .p                over permutations of
     P Q             prime factors of Q with duplicates
  _1              -1

Obrigado @FryAmTheEggman por me lembrar I. Acho que não o usei antes.

Suíte de teste

CJam - 17 bytes

Obrigado a Martin Büttner por me salvar 10 bytes!

Wqimfe!{s_W%=}=p;

Minha primeira vez escrevendo em CJam! Explicação:

W              # Push a -1 onto the stack
q               # Get input
i               # Convert to integer
mf              # Find prime factorization
e!              # Find all permutations
{...}=          # Find permutation which...
s               # Convert to string
_               # Copy string
W%              # Get inverse
=               # Check if inverse == original
p;              # Print top of stack and discard the rest

Ruby, 89 + 7 = 96 102 + 7 = 109

->n{n.prime_division.flat_map{|*a,b|a*b}.permutation.find{|x|x.join==x.join.reverse}||-1}

+7 para a -rprimebandeira.

Suspiro , alguns built-in Ruby têm nomes tão longos ... pelo menos isso torna o código bastante auto-explicativo.

O flat_mapbit é porque prime_divisionretorna ex. [[2, 2], [3, 1]]para entrada 12(que representa ).2231

Obrigado a @histocrat por 13 bytes!

Julia, 132 122 bytes

n->(x=filter(p->(q=join(p))==reverse(q),permutations(foldl(vcat,[[repeated(k,v)...]for(k,v)=factor(n)]))))==[]?-1:first(x)

Essa é uma função lambda que aceita um número inteiro e retorna uma matriz ou -1. Para chamá-lo, atribua-o a uma variável.

Ungolfed:

function f(n::Int)
    # Construct an array of all prime factors of n
    P = foldl(vcat, [[repeated(k, v)...] for (k, v) in factor(n)])

    # Filter the set of permutations of this array to only
    # those such that the string constructed by concatenating
    # all elements is a palindrome
    x = filter(p -> (q = join(p)) == reverse(q), P)

    # If x is empty, return -1, otherwise get the first array
    # in the collection
    return x == [] ? -1 : first(x)
end

Economizou 10 bytes graças a Glen O!

Braquilog , 10 bytes

ḋp.cX↔X∨_1

Experimente online!

  .           The output is
 p            a permutation of
ḋ             the prime factorization of
              the input
   c          such that concatenated
    X         it is the variable X
     ↔        which reversed
      X       is still X;
       ∨      if this is not possible,
              the output is
        _1    -1.

Inicialmente, eu esperava que ter que produzir em -1vez de ter permissão para falhar teria um custo de bytes bastante grande, mas como a saída no caso de sucesso não pode ser concatenada, custa apenas os dois bytes necessários para escrever _1(se se os removêssemos, deixaria a saída sem restrições por padrão e 0, se alterássemos adicionalmente ∨para ∧, o predicado falharia), porque precisamos quebrar a unificação com a saída implícita de qualquer maneira. (Se a concatenação fosse a saída para o sucesso, mas -1ainda assim fosse a falha, teríamos ḋpc.↔|∧_1ou ḋpc.↔.∨_1. No menor caso, em que a saída é concatenada e o predicado pode falhar, a coisa toda é de apenas cinco bytes:ḋpc.↔. Apesar de não apresentar os fatores reais, é mais uma sensação de problema de decisão ...)

Haskell, 122 bytes

import Data.Numbers.Primes
import Data.List
f x=head$[p|p<-permutations$primeFactors x,s<-[show=<<p],s==reverse s]++[[-1]]

Exemplo de uso: f 39-> [3,13].

A abordagem óbvia da força bruta. Iterando todas as permutações dos fatores primos e verifique os palíndromos. Escolha o primeiro. Se não houver, a lista está vazia e o anexo é adicionado [-1].

Perl 6 , 100 bytes

{$/=$_;map(->\f{|({$/%f||($//=f)&&f}...^*!==f)},2..$_).permutations.first({.join.flip eq.join})||-1}

{
  # store copy of argument in $/
  $/ = $_;
  # uses $/ so that I don't have to declare a variable

  # find the prime factors
  map(
    ->\f{
      # Slip so that outer list of all prime factors is flat
      |(
        {
          $/ % f    # return modulus
          ||        # or
          ($/ /= f) # factor the prime out of $/
          &&        # and
          f         # return factor
        }
        # produce a list of them and
        # stop when it returns something other than the factor
        # also ignoring the last non-factor value
        ...^ * !== f
      )
    },
    # find the factors out of the values from 2
    # up to the original argument
    2..$_
    # don't need to skip the non-primes as their
    # prime factorization will have already be
    # factored out of $/
  )

  # try all permutations of the prime factors
  .permutations

  # find the first palindromic one
  .first({ .join.flip eq .join })

  # return -1 if .first returned Nil or empty list
  || -1
}

Uso:

# give it a lexical name
my &prime-palindrome = {...}

say prime-palindrome    1; # -1
say prime-palindrome    2; # (2)
say prime-palindrome   11; # (11)
say prime-palindrome   13; # -1
say prime-palindrome   39; # (3 13)
say prime-palindrome   93; # (31 3)
say prime-palindrome    6; # -1
say prime-palindrome 1207; # (17 71)
say prime-palindrome  393; # -1
say prime-palindrome 2352; # (2 2 7 3 7 2 2)
say prime-palindrome 2351; # -1
say prime-palindrome 2350; # -1

Cerca da metade (53 bytes) é utilizada com o código de fatoração principal.

$/=$_;map(->\f{|({$/%f||($//=f)&&f}...^*!= f)},2..$_)

Se houvesse um prime-factorizemétodo, tudo poderia ser significativamente menor.

{.prime-factorize.permutations.first({.join.flip eq.join})||-1} # 63

Gelatina , 16 bytes

ÆFŒṙŒ!VŒḂ$ƇḢ¹-¹?

Mais do que eu esperava, tanto na contagem de bytes quanto no tempo necessário para escrever.

Experimente online!

Explicação:

ÆFŒṙŒ!VŒḂ$ƇḢ¹-¹?
ÆFŒṙ                Get the prime factors (gets them as exponents then run-length decodes).
    Œ!              Get the permutations.
          Ƈ         Filter (keep) the ones that...
       ŒḂ$          ...are palindromic when...
      V             ...joined.
           Ḣ        Take the first.
              ¹?    If the value is truthy...
            ¹       ...return the value...
             -      else return -1.

Japonês -F-1 , 9 bytes

k á æ_¬êS

Tente

Japonês, 18 bytes

Quase tão curto quanto CJam ...

Uk á f_¬¥Z¬w} g ªJ

Experimente online!

Como funciona

        // Implicit: U = input, e.g. 2352
Uk      // Factorize the input.      [2,2,2,2,3,7,7]
á       // Take permutations.        [[2,2,2,2,3,7,7],[2,2,2,2,7,3,7],[2,2,2,7,2,3,7],...]
f_   }  // Filter to only the ones that return truthily to this function:
Z¬¥Z¬w  //  Return Z.join('') == Z.join('').reverse().
        //                           [[2,2,7,3,7,2,2],[2,7,2,3,2,7,2],[7,2,2,3,2,2,7]]
g       // Take the first item.      [2,2,7,3,7,2,2]
ªJ      // If falsy, resort to -1.   [2,2,7,3,7,2,2]

JavaScript (ES6), 256 244 208 187 bytes

Guardado 36 bytes graças a @Neil

x=>eval("for(a=[],i=2;x>1;x%i?i++:(a.push(i),x/=i));p=-1,f=(z,t=[])=>z[0]?z.map((u,i)=>f([...z.slice(0,i),...z.slice(i+1)],[...t,u])):(y=t.join``)==[...y].reverse().join``&&(p=t),f(a),p")

Define uma função anônima; precede, por exemplo, F=para usá-lo. Na verdade, é bastante rápido na entrada do 2352, levando apenas 150 milissegundos para terminar no meu computador.

APL (NARS), 169 caracteres, 338 bytes

∇r←F w;i;k;a;m;j
  r←⊂,w⋄→0×⍳1≥k←↑⍴w⋄a←⍳k⋄j←i←1⋄r←⍬⋄→C
A: m←i⊃w⋄→B×⍳(i≠1)∧j=m⋄r←r,m,¨∇w[a∼i]⋄j←m
B: i+←1
C: →A×⍳i≤k
∇
G←{F⍵[⍋⍵]}
f←{∨/k←{⍵≡⌽⍵}¨∊¨⍕¨¨v←Gπ⍵:↑k/v⋄¯1}

G seria a função encontrar as permutações ef é a função deste exercício; teste:

  ⎕fmt f¨11 4 39 6 1207 393 2352 
┌7───────────────────────────────────────────────────┐
│┌1──┐ ┌2───┐ ┌2────┐    ┌2─────┐    ┌7─────────────┐│
││ 11│ │ 2 2│ │ 3 13│ ¯1 │ 17 71│ ¯1 │ 2 2 7 3 7 2 2││
│└~──┘ └~───┘ └~────┘ ~~ └~─────┘ ~~ └~─────────────┘2
└∊───────────────────────────────────────────────────┘