Palindromik asal sorunlar oldukça yaygındır, ancak bu sorunun konusu bu değildir. Bu meydan okumada, sayının bir palindrom olması gerekmiyor, asal faktörleri var.

Görev

Kodunuzun girdi olarak tek bir pozitif tam sayı alması gerekir. Ardından, bu tamsayının asal faktörlerinin permütasyonlarından herhangi birinin birleştirildiğinde palindromik olup olmadığını kontrol edin. Öyleyse, bunlardan birini çıktılayın (birleştirilmiş dize değil faktörlerin listesi). Else, çıktı almak zorundasın -1.

Bu kod golf , bayt en kısa kod kazanır!

Test Durumları

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 bayt

Òœ.ΔJÂQ

Çevrimiçi deneyin!

Açıklama:

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

( .Δvarsayılan olarak -1'dir, bu nedenle fazladan çalışmaya gerek yoktur)

Pyth, 14 bayt

@FryAmTheEggman tarafından -2 bayt

h+f_IjkT.pPQ_1

Açıklama:

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

Bana hatırlattığın için teşekkürler @FryAmTheEggman I. Daha önce kullandığımı sanmıyorum.

Test odası

CJam - 17 bayt

Martin Büttner'e beni 10 bayt kurtardığı için teşekkürler !

Wqimfe!{s_W%=}=p;

CJam'de ilk kez yazıyorum! Açıklama:

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

Yakut, 89 + 7 = 96102 + 7 = 109

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

+7 -rprimebayrak için.

Ah , bazı Ruby yapılarının böyle uzun isimleri var ... en azından kodu oldukça açıklayıcı hale getiriyor.

flat_mapBiraz çünkü prime_divisiondöner ex. [[2, 2], [3, 1]]giriş için 12(temsil eder ).2231

@Histokrat 13 bayt için teşekkürler !

Julia, 132122 bayt

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

Bu, bir tamsayıyı kabul eden ve bir dizi veya -1 döndüren lambda işlevidir. Bunu çağırmak için bir değişkene atayın.

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

Glen O sayesinde 10 bayt kurtardı!

Brachylog , 10 bayt

ḋp.cX↔X∨_1

Çevrimiçi deneyin!

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

Başlangıçta, -1başarısız olmasına izin vermek yerine çıktı almanın oldukça büyük bir bayt maliyetinde olmasını bekliyordum, ancak başarı durumunda çıktı birleştirilemediğinden, yazmak için sadece iki bayta mal oluyor _1(eğer biz çıktı varsaymak kısıtsız bırakacaktı, bu kaldırıldı 0ve biz ayrıca değişirse ∨için ∧biz örtülü çıkışı ya yolu ile birleşmesini kırmak gerekir, çünkü), yüklem yerine başarısız olur. (Birleştirme başarı için çıktı olsa -1da yine de başarısızlık için çıktı olsaydı, ḋpc.↔|∧_1ya olurdu ya da ḋpc.↔.∨_1. Çıktının birleştirildiği ve yüklemin başarısız olabileceği en kısa durumda, her şey sadece beş bayttır:ḋpc.↔. Her ne kadar gerçek faktörlerin çıktısını almamak, ona daha fazla karar sorunu hissi veriyor ...

Haskell, 122 bayt

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

Kullanım örneği: f 39-> [3,13].

Açık kaba kuvvet yaklaşımı. Asal faktörlerin tüm permütasyonları üzerinde yineleme ve palindromları kontrol etme. İlkini seçin. Hiçbiri yoksa, liste boştur ve eklenen [-1]dosya atlar.

Perl 6 , 100 bayt

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

Kullanımı:

# 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

Bunun yaklaşık yarısı (53 bayt) asal çarpanlara ayırma kodu ile alınır.

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

Bir prime-factorizeyöntem olsaydı , her şey önemli ölçüde daha kısa olabilirdi.

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

Jöle , 16 bayt

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

Beklediğimden daha uzun, hem bayt sayısında hem de yazma süresinde.

Çevrimiçi deneyin!

Açıklama:

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

k á æ_¬êS

Dene

Japt, 18 bayt

Neredeyse CJam kadar kısa ...

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

Çevrimiçi deneyin!

Nasıl çalışır

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

@Neil sayesinde 36 bayt kaydedildi

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

Anonim bir işlevi tanımlar; örneğin başa ekleyerek F=kullanmak. Aslında 2352 girdisinde oldukça hızlı, bilgisayarımda bitirmek sadece ~ 150 milisaniye sürüyor.

APL (NARS), 169 karakter, 338 bayt

∇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, permütasyonları bulma fonksiyonudur ve f, bu egzersizin fonksiyonudur; Ölçek:

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