एक सकारात्मक पूर्णांक के आंशिक कारक

Question

सकारात्मक पूर्णांक d_1 d_2 ... d_kका एक संग्रह एक सकारात्मक पूर्णांक का एक कारक है nयदि

d_1 * d_2 * ... * d_k = n

प्रत्येक धनात्मक पूर्णांक में एक अद्वितीय अभाज्य गुणनखंडन होता है , लेकिन सामान्य तौर पर उनके कारक भी होते हैं जिनमें कुछ शब्द समग्र होते हैं। उदाहरण के लिए

12 = 6 * 2 = 4 * 3 = 3 * 2 * 2

एक प्रोग्राम, फ़ंक्शन, क्रिया, या समान लिखें जो इनपुट को एक ही सकारात्मक पूर्णांक के रूप में लेता है और इसकी अलग-अलग कारकों की पूरी सूची को रिटर्न या प्रिंट करता है। कारक किसी भी क्रम में उत्पादित किए जा सकते हैं, और उनकी शर्तें किसी भी क्रम में हो सकती हैं, लेकिन कोई भी एक दूसरे के क्रमपरिवर्तन नहीं होना चाहिए। 1दो अपवादों के साथ nकारक शामिल नहीं हो सकते हैं : इनपुट के लिए आप n*1इसके बजाय गुणनखंड दे सकते हैं n; और इनपुट के लिए 1आप 1खाली सूची के बजाय कारक दे सकते हैं ।

आप मान सकते हैं कि इनपुट हस्ताक्षरित 32-बिट पूर्णांक की सीमा में होगा। यदि आउटपुट एक स्ट्रिंग के रूप में है, तो एक कारक के भीतर संख्याओं के परिसीमन और कारक के परिसीमन के बीच एक स्पष्ट अंतर होना चाहिए, लेकिन कारकों के साथ शामिल होने के लिए यह आवश्यक नहीं है (उदाहरण के लिए) *।

आपका कोड एक उचित डेस्कटॉप मशीन पर 10 मिनट के भीतर किसी भी वैध इनपुट को संभालने में सक्षम होना चाहिए।

उदाहरण

1                  [[]]
                or [[1]]
                or [[1 1]]

7                  [[7]]
                or [[7 1]]
                or [[1 7]]

12                 [[12] [6 2] [4 3] [2 3 2]]
                or variants

16                 [[2 2 2 2] [2 2 4] [2 8] [4 4] [16]]
                or variants

901800900          a list of 198091 factorisations

1338557220         a list of 246218 factorisations

Comments

क्या आप कहीं 901800900और 1338557220जहाँ हम उन्हें जाँच सकते हैं, के कारकों की सूची पोस्ट कर सकते हैं? मेरा कोड मुझे उन नंबरों के लिए क्रमशः 2048 और 1024 फैक्टरशिप दे रहा है, और मुझे यकीन नहीं है कि क्यों।

— शर्लक

@ शर्लक 9, जब मैं घर आऊंगा मैं एक ऑनलाइन जनरेटर के साथ क्या कर सकता हूँ आपको 5336100 के लिए एक वैध आउटपुट देना है ।

— पीटर टेलर

यह मुझे एक ProjectEuler चुनौती की याद दिलाता है (दुर्भाग्य से मुझे याद नहीं है जो)। लेकिन वहां आपको उन्हें सूचीबद्ध करने के बजाय कारकों की संख्या की गणना करनी थी।

— निर्दोष

संबंधित OEIS: A001055

— शर्लक

Answer 1

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

_!1=[[]]
i!n=[j:f|j<-[i..n],mod n j<1,f<-j!div n j]
(2!)

(2!)(1338557220::Int)मेरे लैपटॉप पर पांच मिनट में प्रिंट करता है, जब संकलित किया जाता है ghc -O3।

हास्केल, 62 बाइट्स, लेकिन बहुत तेज

i!n|i*i>n=[[n]]|0<1=[i:f|mod n i<1,f<-i!div n i]++(i+1)!n
(2!)

(2!)(1338557220::Int)मेरे लैपटॉप पर एक सेकंड के एक चौथाई में प्रिंट करता है, जब संकलित किया जाता है ghc -O3।

Comments

मैं इसका परीक्षण कैसे करूं? ghcमुझे देता है Parse error: naked expression at top levelऔर मुझे ghciदेता हैparse error on input `='

— पीटर टेलर

@PeterTaylor फ़ंक्शन (2!)को प्रोग्राम के साथ बदलें, इसके साथ main = print ((2!) (1338557220::Int))संकलित करें ghc -O3 factor.hsऔर चलाएं ./factor।

— एंडर्स कासोर्ग

Answer 2

पायथ, 29 बाइट्स

Msam+Ldgd/Hdf!%HT>S@H2tG]]Hg2

M                                def g(G, H):
                   @H2             square root of H
                  S                1-indexed range up to floor
                 >    tG           all but first G − 1 elements
            f                      filter for elements T such that:
              %HT                    H mod T
             !                       is false (0)
   m                               map for elements d:
       gd/Hd                         g(d, H/d)
    +Ld                              prepend d to each element
  a                     ]]H        append [[H]]
 s                                 concatenate
                           g2Q   print g(2, input)

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

1338557220मेरे लैपटॉप पर बीस सेकंड में चलता है ।

Comments

@PeterTaylor सामान्य तरीका: pyth factor.pyth(या pyth -c 'Msam+Ldgd/Hdf!%HT>S@H2tG]]Hg2'), 16स्टड पर उपलब्ध कराना । सुनिश्चित करें कि आप Pyth के वर्तमान संस्करण का उपयोग कर रहे हैं; Qमार्च में निहित जोड़ा गया था। मैं कल्पना नहीं कर सकता कि आप शून्य से विभाजन कैसे प्राप्त कर सकते हैं, हालांकि।

— एंडर्स कासोर्ग जुले

Arrrrgh। मैं "इसके बजाय का उपयोग कर रहा था ', और बैश !%कुछ और करने के लिए विस्तार कर रहा था ।

— पीटर टेलर

Answer 3

पायथन , 252 313 312 311 145 141 137 135 103 84 83 बाइट्स

यह काफी हद तक एंडर्स कसेगोर के पाइथ उत्तर पर आधारित है । किसी भी गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

संपादित करें: 19 बाइट्स डेनिस के लिए धन्यवाद। कोड में एक टाइपो तय किया और एक TIO लिंक जोड़ा।

g=lambda n,m=2:[[n]]+[j+[d]for d in range(m,int(n**.5)+1)if n%d<1for j in g(n/d,d)]

Ungolfed:

def g(n, m=2):
    a = [[n]]
    s = int(n**.5) + 1
    for d in range(m, s):
        if n%d == 0:
            for j in g(n/d, d):
                a.append([d]+j)
    return a

Comments

**.5आयात से छुटकारा मिलता है।

— डेनिस

Answer 4

जावास्क्रिप्ट (ईएस 6), 83 बाइट्स

f=(n,a=[],m=2,i=m)=>{for(;i*i<=n;i++)n%i<1&&f(n/i,[...a,i],i);console.log(...a,n)}

केवल @ AndersKaseorg के वर्गमूल चाल को उधार लिया क्योंकि यह मुझे कुल मिलाकर बाइट्स को बचा रहा था। के 1इनपुट के लिए प्रिंट 1, अन्यथा प्रिंट नहीं करता है 1।

Answer 5

रूबी 1.9+, 87 89 87 बाइट्स

यह उत्तर एंडर्स कसेगोर के पाइथ उत्तर पर आधारित है । यह कोड केवल रूबी 1.9 के बाद के संस्करणों के लिए काम करता है, क्योंकि स्टैबी लैम्ब्डा ->केवल 1.9 में पेश किए गए थे। किसी भी गोल्फ सुझाव का स्वागत है।

g=->n,m=2{(m..Math.sqrt(n)).select{|i|n%i<1}.flat_map{|d|g[n/d,d].map{|j|[d]+j}}+[[n]]}

Ungolfed:

def g(n, m=2)
  a = [[n]]
  s = (m..Math.sqrt(n))
  t = s.select{|i|n%i<1}
  t.each do |d|
    g[n/d,d].each do |j|
      a.push([d]+j)
    end
  end
  return a
end

Comments

क्या इसके लिए रूबी के एक विशेष संस्करण की आवश्यकता है? 1.8.7 के साथ मुझे इस बारे में शिकायत मिलती है g[n/d,d]:wrong number of arguments (0 for 1)

— पीटर टेलर

->रूबी 1.9 में स्पष्ट रूप से लब्ध लामाओं को पेश किया गया था। मैं आवश्यक संस्करण संख्या दिखाने के लिए उत्तर संपादित करूँगा।

— शर्लक

ठीक है धन्यवाद। मैं अब भी उत्सुक हूं g[n/d,d]। g(n/d,d)अधिक पीछे-संगत है।

— पीटर टेलर

आह, f[n]सामान्य रूप से स्टब्बी लैम्ब्डा और रूबी लैम्ब्डा को कॉल करना आवश्यक है। f(n)और f nकॉल की आवश्यकता होती है defऔर end। अधिक जानकारी के लिए यहाँ और यहाँ

— Sherlock9

Answer 6

जे, 52 बाइट्स

[:~.q:<@/:~@(*//.)"$~#@q:_&(;@]<@(,~"{~0,#\@~.)"1)}:

यह उतना कुशल नहीं है जितना कि कुछ कारकों को दोहराया जा सकता है और प्रत्येक कारक को अलग करने और फिर डी-डुप्लिकेट करने के बाद एक अंतिम पास करना पड़ता है।

इसे ऑनलाइन आज़माएं! (लेकिन इनपुट वैल्यू को छोटा रखने की कोशिश करें)।

मेरे डेस्कटॉप पर, टाइमिंग हैं

   f =: [:~.q:<@/:~@(*//.)"$~#@q:_&(;@]<@(,~"{~0,#\@~.)"1)}:
   timex 'r =: f 1338557220'
3.14172
   # r
246218
   timex 'r =: f 901800900'
16.3849
   # r
198091

व्याख्या

यह विधि इनपुट पूर्णांक n के प्रमुख कारकों के लिए सभी सेट विभाजन उत्पन्न करने पर निर्भर करती है । प्रदर्शन सबसे अच्छा होता है जब n वर्ग-मुक्त होता है, अन्यथा डुप्लिकेट कारक बनाए जाएंगे।

[:~.q:<@/:~@(*//.)"$~#@q:_&(;@]<@(,~"{~0,#\@~.)"1)}:  Input: integer n
                                                  }:  Curtail, forms an empty array
                       q:                             Prime factorization
                     #@                               Length, C = count prime factors
                         _&(                     )    Repeat that many times on x = []
                                 (            )"1       For each row
                                            ~.            Unique
                                         #\@              Enumerate starting at 1
                                       0,                 Prepend 0
                                  ,~"{~                   Append each of those to a
                                                          copy of the row
                               <@                         Box it
                            ;&]                         Set x as the raze of those boxes
                                                      These are now the restricted growth
                                                      strings of order C
    q:                                                Prime factorization
            (    )"$~                                 For each RGS
               /.                                       Partition it
             */                                         Get the product of each block
        /:~@                                            Sort it
      <@                                                Box it
[:~.                                                  Deduplicate