양의 정수 n> 1이 주어지면 곱이 n 보다 큰 1보다 큰 정수를 더하여 몇 개의 숫자를 만들 수 있는지 결정하십시오 . 예를 들어, 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

Brachylog , 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보다 큰 요소가있는 목록 만 생성 하는지 확실 하지는 않지만 그렇게하는 것으로 보입니다.

가이아 , 9 14 13 바이트

Jonathan Allan 덕분에 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

젤리 ,  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

파이썬 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))))

수학, 110 바이트

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

자바 스크립트 (ES6) 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)

언 골프 드 :

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

파이썬 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. 최종 함수는 n의 각 파티션의 곱을 가져 와서 합산하여 다른 값의 수를 얻습니다.

의 결과는 2310=2*3*5*7*11입니다 49.

편집 : 아마도 수정이 필요하지만 지금 볼 시간이 없습니다 (서둘러 요). 힌트 : 결과가 맞 2310=2*3*5*7*11습니까? 나는 그렇게 생각하지 않습니다.

EDIT2 : 거대한 수정. 위 참조. 이전 (버기) 버전 : 온라인으로 사용해보십시오!

f첫 번째 요소 (0, n)대신 요소를 사용하여 요소를 계산합니다 (1, n).

람다는 각 요소를 "하위 요인"으로 나누고 그 "하위 요인"을 합칩니다.