4

我编写并使用这个函数来产生一个数字的素数：

import numpy as np
from math import sqrt

def primesfrom3to(n):
    """ Returns a array of primes, p < n """
    assert n>=2
    sieve = np.ones(n/2, dtype=np.bool)
    for i in xrange(3,int(n**0.5)+1,2):
        if sieve[i/2]:
            sieve[i*i/2::i] = False
    return np.r_[2, 2*np.nonzero(sieve)[0][1::]+1]    

def primefactors(tgt,verbose=True):
    if verbose: 
        print '\n\nFinding prime factors of: {:,}'.format(tgt)

    primes=primesfrom3to(sqrt(tgt)+1)

    if verbose:
        print ('{:,} primes between 2 and square root of tgt ({:.4})'.
                      format(len(primes),sqrt(tgt))) 

    return [prime for prime in primes if not tgt%prime]

如果我用Project Euler #3中的值调用它，它会成功生成不同素数的列表：

>>> print primefactors(600851475143)
Finding prime factors of: 600,851,475,143
62,113 primes between 2 and square root of tgt (7.751e+05)
[71, 839, 1471, 6857]

这与Wolfram Alpha为主要因子产生的结果一致。（最大的是 Project Euler #3 的正确答案）

现在假设我想要那个数字 x 1e6 的因数：

>>> print primefactors(600851475143*1000000)
Finding prime factors of: 600,851,475,143,000,000
39,932,602 primes between 2 and square root of tgt (7.751e+08)
[2, 5, 71, 839, 1471, 6857]

对于这个更大的数字，Wolfram Alpha 产生：

2**6 * 5**6 * 71 * 839 * 1471 * 6857

有没有一种简单的方法来修改我的代码，我可以计算2和5作为较大数字的素数的大小？

（我对此的原始代码或算法感兴趣——不是指向可以为我做这件事的库的指针，谢谢！）

4

3 回答 3

8

执行此操作的传统方法是依次划分每个主要因素，然后递归您的因式分解方法。这通常比筛选所有素数要快，因为您只关心实际除数的（少数）素数。

当然，还有很多很多比试除法更好的素因式分解算法；人们通常使用诸如二次筛之类的东西来处理大范围的数字，在小端使用 Pollard 的 rho 方法，在大端使用数域筛。这些都明显要复杂得多。

由于您事先筛选了所有素数，因此您不必关心算法的效率。鉴于此，最简单的方法是事后计算多重性，这就是@tobias_k 所写的。你也可以把它分解成一个单独的函数

def multiplicity(n, p):
    i = 0
    while not n % p:
        i, n = i+1, n/p
    return i

进而

>>> n = 600,851,475,143,000,000
>>> n = 600851475143000000
>>> factors = [2, 5, 71, 839, 1471, 6857]
>>> [(f, multiplicity(n,f)) for f in factors]
[(2, 6), (5, 6), (71, 1), (839, 1), (1471, 1), (6857, 1)]
于 2012-09-04T18:10:40.200 回答
4

一旦你有了不同的主要因素，你可以做这样的事情：

factors = []
for f in distinct_prime_factors:
    while n % f == 0:
        factors.append(f)
        n /= f

现在factors将保存所有主要因素的列表。

于 2012-09-04T18:04:17.827 回答
2

恭敬地，这样更容易（而且更快，更有效）：

from collections import defaultdict
from math import sqrt

def factor(n):
    i = 2
    limit = sqrt(n)    
    while i <= limit:
      if n % i == 0:
        yield i
        n = n / i
        limit = sqrt(n)   
      else:
        i += 1
    if n > 1:
        yield n

def pfac(num):
    d=defaultdict(int)
    for f in factor(num):
        d[f]+=1

    terms=[]
    for e in sorted(d.keys()):
        if d[e]>1:
            terms.append('{:,}^{}'.format(e,d[e]))
        else:
            terms.append('{:,}'.format(e))

    print ' * '.join(terms),'=','{:,}'.format(num)           

pfac(600851475143*1000000-1)
pfac(600851475143*1000000)
pfac(600851475143*1000000+1)

印刷：

83 * 127 * 57,001,373,222,939 = 600,851,475,142,999,999
2^6 * 5^6 * 71 * 839 * 1,471 * 6,857 = 600,851,475,143,000,000
3^2 * 19 * 103 * 197 * 277 * 16,111 * 38,803 = 600,851,475,143,000,001
于 2012-09-05T00:40:48.213 回答