पैलिंड्रोमिक प्राइम समस्याएं बहुत आम हैं, लेकिन यह सवाल यह नहीं है। इस चुनौती में, संख्या का तालमेल नहीं होना चाहिए, इसके प्रमुख कारक हैं।

कार्य

आपके कोड को इनपुट के रूप में एकल धनात्मक पूर्णांक लेना है। फिर जाँच करें कि क्या उस पूर्णांक के मुख्य कारकों में से किसी भी क्रमपरिवर्तन को जब संक्षिप्त किया जाता है। यदि ऐसा है, तो उनमें से एक को आउटपुट करें (कारकों की सूची, समवर्ती स्ट्रिंग नहीं)। और, आपको आउटपुट करना होगा -1।

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है !

परीक्षण के मामलों

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

code-golf palindrome factoring

— Maltysen
स्रोत

1

क्या -1लौटाए जा सकने वाले अन्य भिन्न मूल्य हो सकते हैं ? पर्ल 6 में मैं के बारे में सोच रहा हूँ Nil, Failया अन्य अपरिभाषित मूल्यों। क्या आउटपुट किसी भी स्थितिगत मूल्य का हो सकता है?

— ब्रैड गिल्बर्ट ने 2

सूची, ऐरे, Seq, रेंज, Buf, स्लिप सभी स्थितियां हैं। यही कारण है कि वे स्थितीय भूमिका निभाते हैं।

— ब्रैड गिल्बर्ट

तो .. हम एक खाली सूची के लिए उत्पादन करना चाहिए 1, या -1?

— जो किंग

-1 के रूप में तत्व एक सरणी से भिन्न होता है जिसमें केवल -1 होता है

— रोसल्यूप

4

05AB1E , 7 बाइट्स

Òœ.ΔJÂQ

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

( .Δआसानी से -1 के लिए चूक, तो कोई अतिरिक्त काम की जरूरत नहीं)

— ग्रिमी
स्रोत

3

अजगर, 14 बाइट्स

-2 बाइट्स @FryAmTheEggman द्वारा

h+f_IjkT.pPQ_1

स्पष्टीकरण:

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

धन्यवाद @FryAmTheEggman के बारे में मुझे याद दिलाने के लिए I। मुझे नहीं लगता कि मैंने इसे पहले इस्तेमाल किया है।

परीक्षण सूट

— lirtosiast
स्रोत

jkके रूप में ही हैs`M

— माल्टीसेन

3

सीजाम - 17 बाइट्स

मुझे 10 बाइट्स बचाने के लिए मार्टिन ब्यूटनर का धन्यवाद !

Wqimfe!{s_W%=}=p;

CJam में मेरा पहली बार लेखन! स्पष्टीकरण:

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

— KoreanwGlasses
स्रोत

3

आप एक स्ट्रिंग (या सरणी) को उल्टा कर सकते हैं W%। आप =पहले पलिंडोमिक प्राइम फैक्टरेशन प्राप्त करने के लिए एक ब्लॉक के साथ भी उपयोग कर सकते हैं । यह 18 बाइट्स के लिए बनाता है: Wrimfe!{s_W%=}=p];... आप एक त्रुटि के साथ समाप्त करके एक और बचा सकते हैं (चूंकि त्रुटि आउटपुट STDERR को जाता है):Wrimfe!{s_W%=}=p;

— मार्टिन एंडर

3

@ मार्टिनबटनर यही कारण है कि मुझे पीपीसीजी से प्यार है। हर कोई इतना मददगार और मिलनसार है!

— कोरियाईवैलग्लास

2

रूबी, 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}

-rprimeझंडे के लिए +7 ।

आह , कुछ रूबी बिल्डिंग्स के ऐसे लंबे नाम हैं ... कम से कम यह कोड काफी आत्म-व्याख्यात्मक बनाता है।

flat_mapबिट क्योंकि है prime_divisionरिटर्न उदा। [[2, 2], [3, 1]]इनपुट के लिए 12(जो प्रतिनिधित्व करता है )।2²3¹

13 बाइट्स के लिए @histocrat को धन्यवाद !

— Doorknob
स्रोत

@histocrat ओपी की ओर से एक गलती थी (प्रश्न पर टिप्पणी देखें)। धन्यवाद, यह एक स्वच्छ चाल के साथ है।

— दरवाज़े

2

जूलिया, 132 122 बाइट्स

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

यह एक लैम्ब्डा फ़ंक्शन है जो एक पूर्णांक को स्वीकार करता है और एक सरणी या -1 पर लौटता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

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

ग्लेन हे के लिए 10 बाइट्स धन्यवाद!

— एलेक्स ए।
स्रोत

एक नज़र में, मुझे इसमें सुधार करने के कुछ तरीके दिखाई दे रहे हैं (सिर्फ बुनियादी गोल्फ पर आधारित)। के foldlबजाय का उपयोग करें reduce(वे एक ही काम करते हैं, लेकिन foldlपरिभाषित आदेश है और एक बाइट कम है)। के बजाय एक खाली संरचना के साथ प्रत्यक्ष तुलना का उपयोग करें isempty(मैं 100% निश्चित नहीं हूं कि प्रकार क्या xहै, लेकिन अगर यह एक सेट है, उदाहरण के लिए, उपयोग करें x==[])। और दो और बाइट्स को बचाने के लिए (q=join(p))केवल qफ़िल्टर में उपयोग करें ।

— ग्लेन ओ

इसके अलावा, मुझसे गलती हो सकती है, लेकिन अगर xयह एक सरणी है, तो इसके बजाय first(x), बस उपयोग करें x[]।

— ग्लेन ओ

@GlenO हमेशा की तरह बहुत बहुत धन्यवाद! मैंने शुरू में कोशिश की थी ==[]और यह मुझे त्रुटियाँ दे रहा था लेकिन मैंने फिर से कोशिश की और यह काम कर रहा है। मैंने पहले कुछ गड़बड़ कर दी होगी। ¯ \ _ (ツ) _ / I एकमात्र सुझाव जिसका मैं उपयोग नहीं कर सका first, छुटकारा पा रहा है ; इस मामले में मुझे इसका उपयोग करना है firstक्योंकि xएक पुनरावृत्ति / संग्रह / कुछ ऐसा है जिसे getindexपरिभाषित नहीं किया गया है।

— एलेक्स ए।

2

ब्रेकीलॉग , 10 बाइट्स

ḋp.cX↔X∨_1

इसे ऑनलाइन आज़माएं!

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

प्रारंभ में, मुझे उम्मीद थी कि -1असफल होने के बजाय आउटपुट के लिए काफी बड़ी बाइट लागत होगी, लेकिन चूंकि सफलता के मामले में आउटपुट को संक्षिप्त नहीं किया जा सकता है, इसलिए इसे लिखने के लिए आवश्यक दो बाइट्स की लागत होती है _1(यदि हमने उन को हटा दिया, यह आउटपुट को अनकंस्ट्रेस्ड डिफॉल्टिंग के लिए छोड़ देगा 0, और अगर हमने इसके अलावा इसे बदल दिया ∨है ∧, तो प्रेडिक्ट बदले में विफल हो जाएगा), क्योंकि हमें किसी भी तरह से निहित आउटपुट के साथ एकीकरण को तोड़ने की आवश्यकता है। (यदि अवतरण सफलता के लिए आउटपुट था, लेकिन -1असफलता के लिए अभी भी आउटपुट था, तो हमारे पास होगा करनाḋpc.↔|∧_1 या होगा ḋpc.↔.∨_1। कम से कम मामले में, जहां आउटपुट को संक्षिप्त किया गया है और विधेय विफल हो सकता है, पूरी बात केवल पांच बाइट्स की है:ḋpc.↔। यद्यपि वास्तविक कारकों का उत्पादन नहीं करना इसे निर्णय-समस्या का अधिक अनुभव देता है ...)

— असंबंधित स्ट्रिंग
स्रोत

1

हास्केल, 122 बाइट्स

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

प्रयोग उदाहरण: f 39-> [3,13]।

स्पष्ट जानवर बल दृष्टिकोण। मुख्य कारकों के सभी क्रमपरिवर्तन और पलिंड्रोम्स की जांच करना। पहले वाला चुन लो। यदि कोई नहीं हैं, तो सूची खाली है और इसमें संलग्न [-1]कूदता है।

— nimi
स्रोत

1

पर्ल 6 , 100 बाइट्स

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

उपयोग:

# 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

इसका लगभग आधा (53 बाइट्स) प्राइम फ़ैक्टर कोड के साथ लिया जाता है।

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

अगर कोई prime-factorizeविधि होती तो पूरी चीज काफी छोटी हो सकती थी।

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

— ब्रैड गिल्बर्ट b2gills
स्रोत

एक छोटा प्राइम फैक्टर कोड सेक्शन हो सकता है$!=$_;({+$!/($!/=1+(2...$!%%*))}...{2>$!})

— जो किंग

1

जेली , 16 बाइट्स

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

मेरी अपेक्षा से अधिक, बाइट की गिनती और लिखने में लगने वाले समय दोनों में।

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

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

— कॉमरेड स्पार्कलपनी
स्रोत

1

जाप `-F-1` , 9 बाइट्स

k á æ_¬êS

कोशिश करो

— ओलिवर
स्रोत

इस विंडो फोन में आपका लिंक ठीक नहीं है ...

— RosLuP

@RosLuP दुभाषिया अभी भी काफी नया है। मैं बनाने वाले को झबरा हूँ। यहाँ एक TIO लिंक है

— ओलिवर

1

@RosLuP, आप किस ब्राउज़र का उपयोग कर रहे हैं?

— झबरा

विंडोज फोन 8.1 के लिए इंटरनेट एक्सप्लोरर: (सेलफोन) कुछ ऐसा है जो गायब हो रहा है, संभवतः यह बेहतर है कि मैं अपने ब्रांड के नए फोन एंड्रॉइड का उपयोग करूं या विंडोज़ 10 का ब्राउज़र (ऐसा लगता है कि वे कॉल करते हैं)

— RosLuP

0

जाप, 18 बाइट्स

लगभग CJam जितना छोटा ...

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

— ETHproductions
स्रोत

0

जावास्क्रिप्ट (ईएस 6), 256 244 208 187 बाइट्स

@Neil की बदौलत 36 बाइट्स बचाए

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

एक अनाम फ़ंक्शन को परिभाषित करता है; Prepend F=इसका उपयोग करने के लिए उदा । यह वास्तव में 2352 के इनपुट पर काफी तेज है, केवल मेरे कंप्यूटर पर समाप्त करने के लिए ~ 150 मिलीसेकंड ले रहा है।

— ETHproductions
स्रोत

मैं तेजी से लेकिन निश्चित रूप से कम के बारे में नहीं जानता:

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

— नील

@ नील धन्यवाद, यह भी मेरे एल्गोरिथ्म की तुलना में कुछ गुना तेज होता है!

— ETHproductions

36 बाइट्स? मुझे लगता है कि मेरे लिए एक रिकॉर्ड होना चाहिए।

— नील

0

एपीएल (एनएआरएस), 169 वर्ण, 338 बाइट्स

∇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}

जी समारोह होगा क्रमपरिवर्तन और एफ इस अभ्यास का कार्य है; परीक्षा:

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

— RosLuP
स्रोत

पॉलिंड्रोमिक प्राइम फैक्टर

कार्य

परीक्षण के मामलों

05AB1E , 7 बाइट्स

अजगर, 14 बाइट्स

सीजाम - 17 बाइट्स

रूबी, 89 + 7 = 96 102 + 7 = 109

जूलिया, 132 122 बाइट्स

ब्रेकीलॉग , 10 बाइट्स

हास्केल, 122 बाइट्स

पर्ल 6 , 100 बाइट्स

जेली , 16 बाइट्स

जाप -F-1 , 9 बाइट्स

जाप, 18 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट (ईएस 6), 256 244 208 187 बाइट्स

एपीएल (एनएआरएस), 169 वर्ण, 338 बाइट्स

जाप `-F-1` , 9 बाइट्स