कारकों की संख्या की संख्या

Question

एक सकारात्मक पूर्णांक n> 1 को देखते हुए यह निर्धारित किया जाता है कि पूर्णांक 1 से अधिक है जिसका उत्पाद n है, को जोड़कर कितनी संख्या बनाई जा सकती है । उदाहरण के लिए यदि n = 24 हम व्यक्त कर सकते हैं n निम्न तरीकों से एक उत्पाद के रूप

24 = 24             -> 24            = 24
24 = 12 * 2         -> 12 + 2        = 14
24 = 6 * 2 * 2      -> 6 + 2 + 2     = 10
24 = 6 * 4          -> 6 + 4         = 10
24 = 3 * 2 * 2 * 2  -> 3 + 2 + 2 + 2 = 9
24 = 3 * 4 * 2      -> 3 + 4 + 2     = 9
24 = 3 * 8          -> 3 + 8         = 11

हम निम्नलिखित संख्याएँ इस प्रकार प्राप्त कर सकते हैं:

24, 14, 11, 10, 9

यह कुल 5 संख्या है, इसलिए हमारा परिणाम 5 है।

कार्य

एक प्रोग्राम या फ़ंक्शन लिखें जो इनपुट के रूप में n लेता है और इस तरह से प्राप्त किए जा सकने वाले परिणामों की संख्या लौटाता है।

यह एक कोड-गोल्फ प्रश्न है, इसलिए उत्तर बाइट्स में दिए जाएंगे, कम बाइट बेहतर होने के साथ।

OEIS अनुक्रम

OEIS A069016

Comments

सुझाया गया परीक्षण मामला 240

— जोनाथन एलन

चूंकि 36 ने बहुत बहस की है, इसलिए मैं इसे एक परीक्षण के मामले के रूप में सुझाता हूं।

— user41805

@WheatWizard 12 * 3

— बिजनेस कैट

मेरे पास है 2,2,3,3 -> 10, 2,6,3 -> 11, 2,2,9 -> 13, 12,3 -> 15, 2,18 -> 20,36 -> 36

— बिजनेस बिल्ली

36 7 (2*3)+(2*3)=12होना चाहिए क्योंकि सूची में भी होना चाहिए।

— जोनाथन एलन

Answer 1

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

{~×≜+}ᶜ¹

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

व्याख्या

{    }ᶜ¹  Count unique results of this predicate:
 ~×       Create list of numbers whose product is the input.
   ≜      Label the list, forcing it to take a concrete value.
    +     Take its sum.

मुझे पूरी तरह से यकीन नहीं है कि ~×केवल 1 से ऊपर के तत्वों के साथ सूचियों का उत्पादन क्यों होता है, लेकिन ऐसा करना प्रतीत होता है, जो इस चुनौती में बहुत अच्छा काम करता है।

Comments

यह केवल 1 से ऊपर के तत्वों के साथ सूचियों का उत्पादन करता है क्योंकि अन्यथा असीम रूप से कई सूचियां हैं, जो अक्सर इन जैसी चुनौतियों में खराब होती हैं।

— घातक

Answer 2

गैया , ९ १४ १३ बाइट्स

बग ने जोनाथन एलन के लिए 5 बाइट्स की कीमत पर तय किया, फिर 1 बाइट गोल्फिंग की।

ḍfḍ¦e¦Π¦¦Σ¦ul

इसे ऑनलाइन आज़माएं! या परीक्षण सूट के रूप में प्रयास करें

व्याख्या

ḍ              Prime factors
 f             Permutations
  ḍ¦           Get the partitions of each permutation
    e¦         Dump each list of partitions (1-level flatten the list)
      Π¦¦      Product of each partition
         Σ¦    Sum each group of products
           u   Deduplicate
            l  Length

Comments

क्या आप एक समावेशी TIO लिंक प्रदान कर सकते हैं जिसमें 36 समावेशी के माध्यम से नंबर 1 आउटपुट हो?

— user41805

यह बिल्कुल जैली के जवाब की तरह है ...

— 18

ओपी का कहना है कि 36 के लिए आउटपुट 5 होना चाहिए, न कि 6

— user41805

OEIS के अनुसार, 36 5 के बजाय 7 देता है, लेकिन तुम्हारा 6

— user41805

जाहिरा तौर पर Gaia बाहर निकलता है[6 6]

— user41805

Answer 3

जेली ,  11 15  14 बाइट्स

+4 बाइट्स बग को ठीक करना (शायद एक बेहतर तरीका?)
-1 बाइट सममिति का दुरुपयोग करके

ÆfŒ!ŒṖ€ẎP€S€QL

सकारात्मक पूर्णांकों को लेने और वापस करने वाला एक विचित्र लिंक

इसे ऑनलाइन आज़माएं! या एक परीक्षण सूट देखें

कैसे?

अद्यतन कर रहा है ...

ÆfŒ!ŒṖ€ẎP€S€QL - Link: number, n      e.g. 30
Æf             - prime factors of n        [2,3,5]
  Œ!           - all permutations          [[2,3,5],[2,5,3],[3,2,5],[3,5,2],[5,2,3],[5,3,2]]
    ŒṖ€        - all partitions for €ach   [[[[2],[3],[5]],[[2],[3,5]],[[2,3],[5]],[[2,3,5]]],[[[2],[5],[3]],[[2],[5,3]],[[2,5],[3]],[[2,5,3]]],[[[3],[2],[5]],[[3],[2,5]],[[3,2],[5]],[[3,2,5]]],[[[3],[5],[2]],[[3],[5,2]],[[3,5],[2]],[[3,5,2]]],[[[5],[2],[3]],[[5],[2,3]],[[5,2],[3]],[[5,2,3]]],[[[5],[3],[2]],[[5],[3,2]],[[5,3],[2]],[[5,3,2]]]]
       Ẏ       - tighten                   [[[2],[3],[5]],[[2],[3,5]],[[2,3],[5]],[[2,3,5]],[[2],[5],[3]],[[2],[5,3]],[[2,5],[3]],[[2,5,3]],[[3],[2],[5]],[[3],[2,5]],[[3,2],[5]],[[3,2,5]],[[3],[5],[2]],[[3],[5,2]],[[3,5],[2]],[[3,5,2]],[[5],[2],[3]],[[5],[2,3]],[[5,2],[3]],[[5,2,3]],[[5],[3],[2]],[[5],[3,2]],[[5,3],[2]],[[5,3,2]]]
        P€     - product for €ach          [[30],[6,5],[10,3],[2,3,5],[30],[10,3],[6,5],[2,5,3],[30],[6,5],[15,2],[3,2,5],[30],[15,2],[6,5],[3,5,2],[30],[10,3],[15,2],[5,2,3],[30],[15,2],[10,3],[5,3,2]]
               -   ...this abuses the symmetry saving a byte over P€€
          S€   - sum €ach                  [30,11,13,10,30,13,11,10,30,11,17,10,30,17,11,10,30,13,17,10,30,17,13,10][10,17,11,30,10,17,13,30,10,13,11,30,10,13,17,30,10,11,13,30,10,11,17,30]
            Q  - de-duplicate              [30,11,13,10,17]
             L - length                    5

Answer 4

पायथन 2 , 206 बाइट्स

k=lambda n,i=2:n/i*[k]and[k(n,i+1),[i]+k(n/i)][n%i<1]
def l(t):
 r=[sum(t)]
 for i,a in enumerate(t):
    for j in range(i+1,len(t)):r+=l(t[:i]+[a*t[j]]+t[i+1:j]+t[j+1:])
 return r
u=lambda n:len(set(l(k(n))))

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

व्याख्या

    # Finds the prime factors
k=lambda n,i=2:n/i*[k]and[k(n,i+1),[i]+k(n/i)][n%i<1]
    # Function for finding all possible numbers with some repetition
def l(t):
    # Add the current sum
 r=[sum(t)]
    # For each number in the current factors
 for i,a in enumerate(t):
    # For all numbers further back in the current factors, find all possible numbers when we multiply together two of the factors
    for j in range(i+1,len(t)):r+=l(t[:i]+[a*t[j]]+t[i+1:j]+t[j+1:])
 return r
    # Length of set for distinct elements
u=lambda n:len(set(l(k(n))))

Comments

194 बाइट्स

— ovs

Answer 5

गणितज्ञ, 110 बाइट्स

If[#==1,1,Length@Union[Tr/@Select[Array[f~Tuples~{#}&,Length[f=Rest@Divisors[s=#]]]~Flatten~1,Times@@#==s&]]]&

Answer 6

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

f=(n,o,s=0,i=2,q=n/i)=>(o||(o={},o[n]=t=1),i<n?(q>(q|0)|o[e=s+i+q]||(o[e]=t+=1),f(q,o,s+i),f(n,o,s,i+1)):t)

Ungolfed:

f=(n,                                 //input
   o,                                 //object to hold sums
   s=0,                               //sum accumulator
   i=2,                               //start with 2
   q=n/i                              //quotient
  )=>(
  o||(o={},o[n]=t=1),                 //if first call to function, initialize o[n]
                                      //t holds the number of unique sums
  i<n?(                               //we divide n by all numbers between 2 and n-1
    q>(q|0)|o[e=s+i+q]||(o[e]=t+=1),  //if q is integer and o[s+i+q] is uninitialized,
                                      //... make o[s+i+q] truthy and increment t
    f(q,o,s+i),                       //recurse using q and s+i
    f(n,o,s,i+1)                      //recurse using n with the next i
  ):t                                 //return t
)

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

f=(n,o,s=0,i=2,q=n/i)=>(o||(o={},o[n]=t=1),i<n?(q>(q|0)|o[e=s+i+q]||(o[e]=t+=1),f(q,o,s+i),f(n,o,s,i+1)):t)

s= [];

for(i = 1; i <= 103 ; i++) {
  s.push(f(i));
}

console.log(s.join`, `)

यह सत्यापित करने के लिए कि फ़ंक्शन सही रकम की गणना करता है, हम इसके बजाय ऑब्जेक्ट की कुंजियों को आउटपुट कर सकते हैं t:

f=(n,o,s=0,i=2,q=n/i)=>(o||(o={},o[n]=t=1),i<n?(q>(q|0)|o[e=s+i+q]||(o[e]=t+=1),f(q,o,s+i),f(n,o,s,i+1)):Object.keys(o))

console.log(f(24));  //9, 10, 11, 14, 24

Answer 7

पायथन 3 , 251 बाइट्स

lambda n:1 if n==1else len(set(sum(z)for z in t(f(n))))
f=lambda n:[]if n==1else[[i]+f(n//i)for i in range(2,n+1)if n%i==0][0]
t=lambda l:[l] if len(l)==1else[[l[0]]+r for r in t(l[1:])]+[r[:i]+[l[0]*e]+r[i+1:]for r in t(l[1:])for i,e in enumerate(r)]

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

डिजाइन बुनियादी है:

1. अपने प्रमुख कारकों में n को फ़ैक्टर करें (एक प्रमुख कारक कई बार दिखाई दे सकता है:) 16 -> [2,2,2,2]। यही फंक्शन है f।

2. अभाज्य कारकों की सूची के विभाजन की गणना करें और प्रत्येक विभाजन में कारकों को गुणा करें। विभाजन /programming//a/30134039 के रूप में पाए जाते हैं , और उत्पादों को मक्खी पर गणना की जाती है। यही फंक्शन है t।

3. अंतिम फ़ंक्शन एन के प्रत्येक विभाजन के उत्पादों को प्राप्त करता है और उन्हें रकम देता है, विभिन्न मूल्यों की संख्या प्राप्त करता है।

के लिए परिणाम 2310=2*3*5*7*11है 49।

संपादित करें : शायद ठीक करने की आवश्यकता है, लेकिन मेरे पास इसे देखने का समय नहीं है (मैं जल्दी में हूँ)। संकेत: क्या परिणाम के लिए सही है 2310=2*3*5*7*11? मुझे ऐसा नहीं लगता।

EDIT2 : विशाल फिक्स। ऊपर देखो। पिछला (छोटी गाड़ी) संस्करण था: इसे ऑनलाइन आज़माएं!

fपहले तत्व के (0, n)बजाय (, के साथ कारकों की गणना करता है (1, n)।

लैम्ब्डा प्रत्येक कारक को "उप-कारकों" में विभाजित करता है और उन "उप-कारकों" को पूरा करता है।

Comments

-19 बाइट्स

— notjagan

@ नॉटजागन सुधार से -1 बाइट

— हल्वार्ड् यस

@Notjagan के लिए धन्यवाद, लेकिन प्रारंभिक कोड तो गलत था ...

— jferard

@HalvardHummel के लिए धन्यवाद, लेकिन ऊपर की तरह ही टिप्पणी।

— जेफर्ड