Masalah utama palindromik cukup umum, tapi bukan itu pertanyaannya. Dalam tantangan ini, angkanya tidak harus menjadi palindrom, faktor utamanya adalah.

Tugas

Kode Anda harus mengambil satu bilangan bulat positif sebagai input. Kemudian periksa apakah ada permutasi faktor prima dari bilangan bulat itu palindromik ketika digabungkan. Jika demikian, output salah satunya (daftar faktor, bukan string yang disatukan). Lain, Anda harus output -1.

Ini adalah kode-golf , jadi kode terpendek dalam byte menang!

Uji Kasus

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 byte

Òœ.ΔJÂQ

Cobalah online!

Penjelasan:

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

( .Δmudahnya default ke -1, jadi tidak perlu kerja ekstra)

Pyth, 14 byte

-2 byte oleh @FryAmTheEggman

h+f_IjkT.pPQ_1

Penjelasan:

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

Terima kasih @FryAmTheEggman untuk mengingatkan saya tentang I. Saya tidak berpikir saya pernah menggunakannya sebelumnya.

Suite uji

CJam - 17 byte

Terima kasih kepada Martin Büttner karena telah menyelamatkan saya 10 byte!

Wqimfe!{s_W%=}=p;

Saya pertama kali menulis di CJam! Penjelasan:

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

Huh , beberapa Ruby bawaan memiliki nama yang panjang ... setidaknya itu membuat kodenya cukup jelas.

The flat_mapbit karena prime_divisionreturn ex. [[2, 2], [3, 1]]untuk input 12(yang mewakili ).2231

Terima kasih kepada @ histokrat selama 13 byte!

Julia, 132 122 byte

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

Ini adalah fungsi lambda yang menerima integer dan mengembalikan array atau -1. Untuk menyebutnya, tetapkan ke variabel.

Tidak Disatukan:

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

Disimpan 10 byte berkat Glen O!

Brachylog , 10 byte

ḋp.cX↔X∨_1

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

Pada awalnya, saya berharap bahwa harus mengeluarkan -1daripada diizinkan untuk gagal akan menjadi biaya byte yang cukup besar, tetapi karena output dalam kasus keberhasilan tidak dapat digabungkan, hanya biaya dua byte yang diperlukan untuk menulis _1(jika kami menghapusnya, itu akan membuat output tidak dibatasi menjadi default 0, dan jika kita juga mengubah ∨ke ∧, predikat akan gagal sebagai gantinya), karena kita perlu memutus penyatuan dengan output implisit dengan cara apa pun. (Jika rangkaian adalah output untuk sukses tetapi -1masih output untuk kegagalan, kita akan memiliki ḋpc.↔|∧_1atauḋpc.↔.∨_1 . Dalam kasus terpendek, di mana output disatukan dan predikat dapat gagal, semuanya hanya lima byte:ḋpc.↔. Meskipun tidak mengeluarkan faktor-faktor yang sebenarnya memberikan lebih banyak perasaan keputusan-masalah ...)

Haskell, 122 byte

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

Contoh penggunaan: f 39-> [3,13].

Pendekatan brute force yang jelas. Iterasi semua permutasi faktor prima dan periksa palindrom. Pilih yang pertama. Jika tidak ada, daftar kosong dan ditambahkan terlampir [-1].

Perl 6 , 100 byte

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

Pemakaian:

# 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

Sekitar setengahnya (53 byte) diambil dengan kode faktorisasi utama.

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

Jika ada prime-factorizemetode semuanya bisa jauh lebih pendek.

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

Jelly , 16 byte

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

Lebih lama dari yang saya harapkan, baik dalam hitungan byte dan waktu yang dibutuhkan untuk menulis.

Cobalah online!

Penjelasan:

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

k á æ_¬êS

Cobalah

Japt, 18 byte

Hampir sesingkat CJam ...

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

Cobalah online!

Bagaimana itu bekerja

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

Disimpan 36 byte berkat @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")

Menentukan fungsi anonim; misalnya tambahkan F=untuk menggunakannya. Ini sebenarnya cukup cepat pada input 2352, hanya butuh ~ 150 milidetik untuk menyelesaikannya di komputer saya.

APL (NARS), 169 karakter, 338 byte

∇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 akan menjadi fungsi menemukan permutasi dan f adalah fungsi dari latihan ini; uji:

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