Cho một số nguyên dương n> 1 xác định có bao nhiêu số có thể được thực hiện bằng cách thêm các số nguyên lớn hơn 1 có sản phẩm là n . Ví dụ: nếu n = 24, chúng ta có thể biểu thị n dưới dạng sản phẩm theo các cách sau

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

Chúng ta có thể nhận được các số sau theo cách này:

24, 14, 11, 10, 9

Đó là tổng cộng 5 số, vì vậy kết quả của chúng tôi là 5.

Bài tập

Viết chương trình hoặc hàm lấy n làm đầu vào và trả về số lượng kết quả có thể thu được theo cách này.

Đây là một câu hỏi golf-code vì vậy câu trả lời sẽ được tính bằng byte, với ít byte hơn sẽ tốt hơn.

Trình tự OEIS

OEIS A069016

Brachylog , 8 byte

{~×≜+}ᶜ¹

Hãy thử trực tuyến!

Giải trình

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

Tôi không hoàn toàn chắc chắn tại sao ~×chỉ tạo ra các danh sách có các yếu tố trên 1, nhưng dường như nó làm như vậy, hoạt động rất tốt trong thử thách này.

Gaia , 9 14 13 byte

Lỗi đã được sửa với giá 5 byte nhờ Jonathan Allan, sau đó là 1 byte đánh gôn.

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

Hãy thử trực tuyến! hoặc thử như một bộ thử nghiệm

Giải trình

ḍ              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

Thạch ,  11 15  14 byte

+4 byte sửa lỗi (có thể là cách tốt hơn?)
-1 byte bằng cách lạm dụng tính đối xứng

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

Một liên kết đơn lấy và trả về số nguyên dương

Hãy thử trực tuyến! hoặc xem một bộ thử nghiệm

Làm sao?

Đang cập nhật ...

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

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

Hãy thử trực tuyến!

Giải trình

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

Toán học, 110 byte

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

JavaScript (ES6) 107 byte

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)

Ung dung:

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
)

Các trường hợp thử nghiệm:

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

Để xác minh rằng hàm tính toán các khoản tiền chính xác, chúng ta có thể xuất các khóa của đối tượng thay vì 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 byte

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

Hãy thử trực tuyến!

Thiết kế là cơ bản:

1. thừa số n thành các thừa số nguyên tố của nó (một thừa số nguyên tố có thể xuất hiện nhiều lần 16 -> [2,2,2,2]:). Đó là chức năng f.

2. tính toán các phân vùng của danh sách các thừa số nguyên tố và nhân các yếu tố trong mỗi phân vùng. Các phân vùng được tìm thấy như trong /programming//a/30134039 và các sản phẩm được tính toán nhanh chóng. Đó là chức năng t.

3. Hàm cuối cùng lấy các sản phẩm của từng phân vùng của n và tính tổng chúng, lấy số lượng các giá trị khác nhau.

Kết quả cho 2310=2*3*5*7*11là 49.

EDIT : Có thể cần sửa chữa, nhưng tôi không có thời gian để xem xét nó bây giờ (tôi đang vội). Gợi ý: kết quả có đúng 2310=2*3*5*7*11không? Tôi không nghĩ vậy.

EDIT2 : Sửa chữa rất lớn. Xem ở trên. Phiên bản (lỗi) trước đó là: Dùng thử trực tuyến!

ftính toán các yếu tố (, với (0, n)thay vì (1, n)là yếu tố đầu tiên.

Lambda phân chia từng yếu tố trong "các yếu tố phụ" và tính tổng các "yếu tố phụ" đó.