Pozitif bir n> 1 tamsayısı verildiğinde , ürünü n olan 1'den büyük tamsayılar ekleyerek kaç sayı yapılabileceğini belirleyin . Örneğin eğer n = 24 biz ifade edebiliriz n aşağıdaki şekillerde bir ürün olarak

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

Aşağıdaki numaraları bu şekilde alabiliriz:

24, 14, 11, 10, 9

Bu toplam 5 sayıdır, dolayısıyla sonucumuz 5'tir.

Görev

Alan bir program ya da işlev Yazın , n girdi olarak alır ve bu şekilde elde edilebilir sonuçların sayısını verir.

Bu bir kod golf sorusudur, bu nedenle cevaplar bayt cinsinden puanlandırılacak, daha az bayt daha iyi olacaktır.

OEIS dizisi

OEIS A069016

Brachylog , 8 bayt

{~×≜+}ᶜ¹

Çevrimiçi deneyin!

açıklama

{    }ᶜ¹  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.

Neden ~×sadece 1'in üzerinde öğeler içeren listeler ürettiğinden tam olarak emin değilim , ancak öyle görünüyor ki, bu meydan okumada harika çalışıyor.

Gaia , 9 14 13 bayt

Jonathan Allan sayesinde 5 baytlık bir hata giderildi, sonra 1 bayt golf oynadı.

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

Çevrimiçi deneyin! veya bir test paketi olarak deneyin

açıklama

ḍ              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

Jöle ,  11 15  14 bayt

Bir hatayı düzelten +4 bayt (belki daha iyi bir yol?)
-1 bayt simetriyi kötüye kullanarak

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

Pozitif tamsayıları alan ve döndüren monadik bir bağlantı

Çevrimiçi deneyin! veya bir test takımına bakın

Nasıl?

Güncelleniyor ...

Æ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

Python 2 , 206 bayt

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

Çevrimiçi deneyin!

açıklama

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

Mathematica, 110 bayt

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

JavaScript (ES6) 107 bayt

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
)

Test senaryoları:

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`, `)

İşlevin doğru toplamları hesapladığını doğrulamak için, nesnenin tuşlarını aşağıdaki yerine verebiliriz 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

Python 3 , 251 bayt

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

Çevrimiçi deneyin!

Tasarım temel:

1. n'yi asal çarpanlarına ayırır (asal çarpan birkaç kez ortaya çıkabilir:) 16 -> [2,2,2,2]. İşlev bu f.

2. asal faktörler listesinin bölümlerini hesaplar ve her bölümdeki faktörleri çarpar. Bölümler /programming//a/30134039 adresinde olduğu gibi bulunur ve ürünler anında hesaplanır. İşlev bu t.

3. Son fonksiyon, n'nin her bir bölümünün ürünlerini alır ve onları toplar, farklı değerlerin sayısını alır.

İçin sonuç 2310=2*3*5*7*11DİR 49.

EDIT : Belki düzeltilmesi gerekiyor, ama şimdi bakmak için zamanım yok (acelem var). İpucu: sonuç doğru 2310=2*3*5*7*11mu? Ben öyle düşünmüyorum.

EDIT2 : Büyük düzeltme. Yukarıyı görmek. Önceki (buggy) version was: Try it online!

ffaktörleri hesaplar ( ilk eleman olarak (0, n)değil, yerine (1, n).

Lambda her faktörü "alt faktörler" olarak ayırır ve bu "alt faktörleri" toplar.