Các vấn đề cơ bản của Palindromic khá phổ biến, nhưng đó không phải là câu hỏi này. Trong thử thách này, con số không nhất thiết phải là một bảng màu, các yếu tố chính của nó là.

Bài tập

Mã của bạn phải lấy một số nguyên dương duy nhất làm đầu vào. Sau đó kiểm tra xem có bất kỳ hoán vị nào của các thừa số nguyên tố của số nguyên đó là palindromic khi nối không. Nếu vậy, hãy xuất một trong số chúng (danh sách các yếu tố, không phải chuỗi nối). Khác, bạn phải đầu ra -1.

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

Các trường hợp thử nghiệm

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

Hãy thử trực tuyến!

Giải trình:

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

( .Δthuận tiện mặc định là -1, vì vậy không cần làm thêm)

Bình thường, 14 byte

-2 byte bởi @FryAmTheEggman

h+f_IjkT.pPQ_1

Giải trình:

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

Cảm ơn @FryAmTheEggman đã nhắc nhở tôi về I. Tôi không nghĩ rằng tôi đã sử dụng nó trước đây.

Bộ kiểm tra

CJam - 17 byte

Cảm ơn Martin Büttner đã tiết kiệm cho tôi 10 byte!

Wqimfe!{s_W%=}=p;

Lần đầu tiên tôi viết ở CJam! Giải trình:

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

Hồng ngọc, 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 cho -rprimecờ.

Thở dài , một số nội dung của Ruby có tên dài như vậy ... ít nhất điều đó làm cho mã khá tự giải thích.

Các flat_mapbit là vì prime_divisiontrả về ex. [[2, 2], [3, 1]]cho đầu vào 12(đại diện ).2231

Cảm ơn @histocrat cho 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)

Đây là hàm lambda chấp nhận một số nguyên và trả về một mảng hoặc -1. Để gọi nó, gán nó cho một biến.

Ung dung:

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

Đã lưu 10 byte nhờ Glen O!

Brachylog , 10 byte

ḋp.cX↔X∨_1

Hãy thử trực tuyến!

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

Ban đầu, tôi đã dự kiến ​​rằng việc phải xuất ra -1thay vì được phép thất bại sẽ có chi phí byte khá lớn, nhưng vì đầu ra trong trường hợp thành công không thể được nối, nên chỉ mất hai byte cần thiết để viết _1(nếu chúng tôi loại bỏ những, nó sẽ rời khỏi đầu ra không bị giới hạn mặc định cho 0, và nếu chúng ta thay đổi bổ sung các ∨đến ∧, vị sẽ không thay), bởi vì chúng ta cần phải phá vỡ sự thống nhất với sản lượng tiềm ẩn một trong hai cách. (Nếu kết nối là đầu ra cho thành công nhưng -1vẫn là đầu ra cho sự thất bại, chúng ta sẽ có ḋpc.↔|∧_1hoặc ḋpc.↔.∨_1. Trong trường hợp ngắn nhất, khi đầu ra được nối và biến vị ngữ có thể thất bại, toàn bộ chỉ có năm byte:ḋpc.↔. Mặc dù không xuất ra các yếu tố thực tế mang lại cho nó nhiều cảm giác về vấn đề quyết định hơn ...)

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

Ví dụ sử dụng: f 39-> [3,13].

Cách tiếp cận vũ phu rõ ràng. Lặp lại tất cả các hoán vị của các yếu tố chính và kiểm tra palindroms. Chọn cái đầu tiên. Nếu không có, danh sách trống và phần bổ sung sẽ [-1]nhảy vào.

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
}

Sử dụng:

# 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

Khoảng một nửa trong số đó (53 byte) được sử dụng với mã thừa số nguyên tố.

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

Nếu có một prime-factorizephương pháp thì toàn bộ điều có thể ngắn hơn đáng kể.

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

Thạch , 16 byte

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

Dài hơn tôi mong đợi, cả về số byte và thời gian viết.

Hãy thử trực tuyến!

Giải trình:

Æ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

Thử nó

Japt, 18 byte

Gần như ngắn như ...

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

Đã lưu 36 byte nhờ @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")

Xác định một hàm ẩn danh; trả trước ví dụ F=để sử dụng nó. Nó thực sự khá nhanh với đầu vào 2352, chỉ mất ~ 150 mili giây để hoàn thành trên máy tính của tôi.

APL (NARS), 169 ký tự, 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 sẽ là hàm tìm hoán vị và f là hàm của bài tập này; kiểm tra:

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