正整数的部分分解


23

正整数的集合是正整数d_1 d_2 ... d_k因式分解n如果

d_1 * d_2 * ... * d_k = n

每个正整数都有一个唯一的素因式分解,但通常它们也具有其中某些项是复合的分解。例如

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

编写一个程序,函数,动词或类似物,将单个正整数作为输入并返回或打印其不同因式分解的完整列表。分解可以以任何顺序生成,并且它们的项可以以任何顺序生成,但是彼此之间不应有两个置换。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

您可以在9018009001338557220我们可以检查的地方张贴因式分解的清单吗?我的代码分别为这些数字提供了2048和1024的因式分解,但我不确定为什么。
Sherlock16年

@ Sherlock9,当我回到家时会这样做。我可以使用在线生成器为您提供5336100的有效输出
彼得·泰勒

3
这使我想起了ProjectEuler的挑战(不幸的是,我不记得是哪个挑战)。但是在那里,您必须计算分解因子的数量,而不是列出它们。
瑕疵的

相关的OEIS:A001055
Sherlock9'9

Answers:


12

Haskell,56个字节

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

(2!)(1338557220::Int)使用编译时,可在笔记本电脑上用五分钟打印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)使用编译时,可以在笔记本电脑上打印四分之一秒ghc -O3


我该如何测试?ghc给我Parse error: naked expression at top levelghci给我parse error on input `='
彼得·泰勒

@PeterTaylor用(2!)程序替换函数main = print ((2!) (1338557220::Int)),使用编译ghc -O3 factor.hs并运行./factor
Anders Kaseorg '16

7

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在我的笔记本电脑上运行二十秒钟。


@PeterTaylor常用方法:(pyth factor.pythpyth -c 'Msam+Ldgd/Hdf!%HT>S@H2tG]]Hg2'),16在stdin上提供。确保您使用的是最新版本的Pyth。隐式Q添加于三月。不过,我无法想象您将如何除以零。
Anders Kaseorg '16

啊 我使用"而不是',而bash将扩展!%到其他东西。
彼得·泰勒

6

Python252 313 312 311 145 141 137 135 103 84 83字节

这很大程度上基于Anders Kaseorg的Pyth答案。欢迎任何打高尔夫球的建议。在线尝试!

编辑:感谢丹尼斯打了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

1
**.5摆脱了进口。
丹尼斯

4

JavaScript(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

Ruby 1.9 +,87 89 87字节

该答案基于Anders Kaseorg的Pyth答案。该代码仅适用于Ruby 1.9之后的版本,因为稳定的lambda ->仅在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

这是否需要特定版本的Ruby?我收到1.8.7的投诉g[n/d,d]wrong number of arguments (0 for 1)
彼得·泰勒

显然,稳定的lambda ->是在Ruby 1.9中引入的。我将编辑答案以显示所需的版本号。
Sherlock16年

好,谢谢。我仍然很好奇g[n/d,d]g(n/d,d)向后兼容。
彼得·泰勒

1
啊,f[n]通常需要调用stabby lambda和Ruby lambdas。f(n)f n通话需要defend在这里这里的
Sherlock9

1

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
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.