양의 정수의 집합은 d_1 d_2 ... d_kA는 인수 분해 양의 정수의 n경우

d_1 * d_2 * ... * d_k = n

각 양의 정수에는 고유 한 소인수 분해 가 있지만 일반적으로 일부 항이 복합 인 인수 분해도 있습니다. 예 :

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

단일 양의 정수를 입력으로 사용하고 고유 한 인수 분해의 전체 목록을 반환하거나 인쇄하는 프로그램, 함수, 동사 또는 이와 유사한 프로그램을 작성하십시오. 인수 분해는 임의의 순서로 생성 될 수 있으며, 그 항은 임의의 순서로있을 수 있지만, 둘은 서로 순열되지 않아야합니다. Factorisations는 포함되지 않을 수 있습니다 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

하스켈, 56 바이트

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

(2!)(1338557220::Int)로 컴파일 할 때 랩톱에서 5 분 안에 인쇄됩니다 ghc -O3.

Haskell, 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)로 컴파일하면 1/4 초 안에 노트북에 인쇄됩니다 ghc -O3.

Pyth, 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내 노트북 에서 20 초 안에 실행됩니다 .

파이썬 , 252 313 312 311 145 141 137 135 103 84 83 바이트

이것은 주로 Anders Kaseorg의 Pyth answer 에 기반합니다 . 모든 골프 제안을 환영합니다. 온라인으로 사용해보십시오!

편집 : Dennis 덕분에 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)]

언 골프 드 :

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

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

루비 1.9+, 87 89 87 바이트

이 답변은 Anders Kaseorg의 Pyth 답변을 기반으로 합니다. 이 코드는 스테이 비 람다 ->는 1.9에서만 도입 되었기 때문에 Ruby 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]]}

언 골프 드 :

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

J, 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