Les problèmes palindromiques premiers sont assez courants, mais ce n'est pas de cela qu'il s'agit. Dans ce défi, le nombre n'a pas à être un palindrome, ses facteurs premiers le font.

Tâche

Votre code doit prendre un seul entier positif en entrée. Vérifiez ensuite si l'une des permutations des facteurs premiers de cet entier est palindromique lorsqu'elle est concaténée. Si c'est le cas, affichez l'un d'eux (la liste des facteurs, pas la chaîne concaténée). Sinon, vous devez sortir -1.

C'est le code-golf , donc le code le plus court en octets gagne!

Cas de test

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 octets

Òœ.ΔJÂQ

Essayez-le en ligne!

Explication:

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

( .Δcommodément par défaut à -1, donc aucun travail supplémentaire n'est nécessaire)

Pyth, 14 octets

-2 octets par @FryAmTheEggman

h+f_IjkT.pPQ_1

Explication:

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

Merci @FryAmTheEggman de me l'avoir rappelé I. Je ne pense pas l'avoir utilisé auparavant.

Suite de tests

CJam - 17 octets

Merci à Martin Büttner de m'avoir économisé 10 octets!

Wqimfe!{s_W%=}=p;

Ma première fois en écrivant dans CJam! Explication:

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

Rubis, 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 pour le -rprimedrapeau.

Soupir , certains buildins Ruby ont des noms si longs ... du moins, cela rend le code assez explicite.

Le flat_mapbit est parce que prime_divisionretourne ex. [[2, 2], [3, 1]]pour l'entrée 12(qui représente ).2231

Merci à @histocrat pour 13 octets!

Julia, 132 122 octets

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

Il s'agit d'une fonction lambda qui accepte un entier et retourne un tableau ou -1. Pour l'appeler, affectez-le à une variable.

Non golfé:

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

10 octets enregistrés grâce à Glen O!

Brachylog , 10 octets

ḋp.cX↔X∨_1

Essayez-le en ligne!

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

Au départ, je m'attendais à ce que la sortie -1au lieu d'être autorisée à échouer ait un coût en octets assez élevé, mais comme la sortie en cas de succès ne peut pas être concaténée, cela ne coûte que les deux octets nécessaires pour écrire _1(si nous les avons supprimés, cela laisserait la sortie sans contrainte par défaut à 0, et si nous avons également changé la valeur ∨en ∧, le prédicat échouera à la place), car nous devons rompre l'unification avec la sortie implicite dans les deux cas. (Si la concaténation était la sortie pour le succès mais -1était toujours la sortie pour l'échec, nous aurions ḋpc.↔|∧_1ou ḋpc.↔.∨_1. Dans le cas le plus court, où la sortie est concaténée et le prédicat peut échouer, le tout n'est que de cinq octets:ḋpc.↔. Bien que ne pas produire les facteurs réels, cela donne plus une sensation de problème de décision ...)

Haskell, 122 octets

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

Exemple d'utilisation: f 39-> [3,13].

L'approche évidente de la force brute. Itérer sur toutes les permutations des facteurs premiers et vérifier les palindromes. Choisissez le premier. S'il n'y en a pas, la liste est vide et le fichier ajouté [-1]apparaît.

Perl 6 , 100 octets

{$/=$_;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
}

Usage:

# 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

Environ la moitié (53 octets) est occupée par le code de factorisation premier.

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

S'il y avait une prime-factorizeméthode, le tout pourrait être beaucoup plus court.

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

Gelée , 16 octets

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

Plus long que prévu, à la fois en nombre d'octets et en temps d'écriture.

Essayez-le en ligne!

Explication:

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

Japt -F-1 , 9 octets

k á æ_¬êS

Essayez-le

Japt, 18 octets

Presque aussi court que CJam ...

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

Essayez-le en ligne!

Comment ça fonctionne

        // 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 octets

36 octets enregistrés grâce à @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")

Définit une fonction anonyme; ajouter par exemple F=pour l'utiliser. Il est en fait assez rapide à l'entrée de 2352, ne prenant que ~ 150 millisecondes pour terminer sur mon ordinateur.

APL (NARS), 169 caractères, 338 octets

∇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 serait la fonction trouver les permutations et f est la fonction de cet exercice; tester:

  ⎕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
└∊───────────────────────────────────────────────────┘