Question

我正在尝试实现一个函数primeFac()，它将一个正整数n作为输入，并返回一个列表，其中包含n的素数因子分解中的所有数字。

我已经做到这一点，但我认为在这里使用递归会更好，不知道如何在这里创建递归代码，什么是基本情况？开头。

我的代码：

def primes(n):
    primfac = []
    d = 2
    while (n > 1):
         if n%d==0:
             primfac.append(d)
    # how do I continue from here... ?

Answer 1

一个简单的试验部门：

def primes(n):
    primfac = []
    d = 2
    while d*d <= n:
        while (n % d) == 0:
            primfac.append(d)  # supposing you want multiple factors repeated
            n //= d
        d += 1
    if n > 1:
       primfac.append(n)
    return primfac

O(sqrt(n))复杂度（最坏情况）。您可以通过特殊套管2轻松改进它，并仅在奇数d（或特殊套管更小的素数并在更少的可能除数上循环）循环。

Answer 2

这是一个基于理解的解决方案，它可能是最接近Python的递归解决方案，同时可以用于大数字。

你可以用一行获得适当的除数：

divisors = [ d for d in xrange(2,int(math.sqrt(n))) if n % d == 0 ]

然后我们可以测试除数中的数字是否为素数：

def isprime(d): return all( d % od != 0 for od in divisors if od != d )

测试没有其他除数划分d。

然后我们可以过滤主要除数：

prime_divisors = [ d for d in divisors if isprime(d) ]

当然，它可以组合在一个功能中：

def primes(n):
    divisors = [ d for d in range(2,n//2+1) if n % d == 0 ]
    return [ d for d in divisors if \
             all( d % od != 0 for od in divisors if od != d ) ]

在这里，\是打破界限而不会弄乱Python缩进。

Answer 3

primefac module对数学家几个世纪以来所开发的所有奇特技术进行了分析：

#!python

import primefac
import sys

n = int( sys.argv[1] )
factors = list( primefac.primefac(n) )
print '\n'.join(map(str, factors))

Answer 4

这是我的试验分解的分解版本，其中包括仅由2分割的优化和Daniel Fischer提出的奇数整数：

def factors(n):
    f, fs = 3, []
    while n % 2 == 0:
        fs.append(2)
        n /= 2
    while f * f <= n:
        while n % f == 0:
            fs.append(f)
            n /= f
        f += 2
    if n > 1: fs.append(n)
    return fs

试验除以2和奇数的改进是轮分解，它使用潜在素数之间的一组循环间隙来大大减少试验分割的数量。这里我们使用2,3,5轮：

def factors(n):
    gaps = [1,2,2,4,2,4,2,4,6,2,6]
    length, cycle = 11, 3
    f, fs, nxt = 2, [], 0
    while f * f <= n:
        while n % f == 0:
            fs.append(f)
            n /= f
        f += gaps[nxt]
        nxt += 1
        if nxt == length:
            nxt = cycle
    if n > 1: fs.append(n)
    return fs

因此，print factors(13290059)将输出[3119, 4261]。保理轮具有与正常试验分区相同的O（sqrt（n））时间复杂度，但在实践中将快两到三倍。

我在my blog的素数做了很多工作。请随时访问和学习。

Answer 5

上述大部分解决方案似乎都不完整。素数分解将重复数字(e.g. 9 = [3 3])的每个素数因子。

此外，上述解决方案可以编写为惰性函数以方便实现。

使用 sieve Of Eratosthenes 来查找要测试的素数是最佳的，但是;上面的实现使用了比必要更多的内存。

我不确定 "wheel factorization" 是否/如何优于仅应用素因子，用于n的除法测试。

虽然这些解决方案确实有用，但我建议以下两个功能 -

功能-1：

def primes(n):
    if n < 2: return
    yield 2
    plist = [2]
    for i in range(3,n):
        test = True
        for j in plist:
            if j>n**0.5:
                break
            if i%j==0:
                test = False
                break
        if test:
            plist.append(i)
            yield i

功能-2：

def pfactors(n):
    for p in primes(n):
        while n%p==0:
            yield p
            n=n//p
            if n==1: return

list(pfactors(99999))
[3, 3, 41, 271]

3*3*41*271
99999

list(pfactors(13290059))
[3119, 4261]

3119*4261
13290059

Answer 6

我已经调整@ user448810的答案，使用来自itertools的迭代器（和python3.4，但它应该是可以后移的）。解决方案的速度提高了约15％。

import itertools

def factors(n):
    f = 2
    increments = itertools.chain([1,2,2], itertools.cycle([4,2,4,2,4,6,2,6]))
    for incr in increments:
        if f*f > n:
            break
        while n % f == 0:
            yield f
            n //= f
        f += incr
    if n > 1:
        yield n

请注意，这会返回一个可迭代的，而不是一个列表。如果这是你想要的，请将它包装在list（）中。

Answer 7

def get_prime_factors(number):
    """
    Return prime factor list for a given number
        number - an integer number
        Example: get_prime_factors(8) --> [2, 2, 2].
    """
    if number == 1:
        return []

    # We have to begin with 2 instead of 1 or 0
    # to avoid the calls infinite or the division by 0
    for i in xrange(2, number):
        # Get remainder and quotient
        rd, qt = divmod(number, i)
        if not qt: # if equal to zero
            return [i] + get_prime_factors(rd)

    return [number]

Answer 8

数字的主要因素：

def primefactors(x):
    factorlist=[]
    loop=2
    while loop<=x:
        if x%loop==0:
            x//=loop
            factorlist.append(loop)
        else:
            loop+=1
    return factorlist

x = int(input())
alist=primefactors(x)
print(alist)

您将获得该列表。如果你想获得一对数的素数因子，试试这个： http://pythonplanet.blogspot.in/2015/09/list-of-all-unique-pairs-of-prime.html

Answer 9

我想分享我的代码来查找用户输入的给定数字的主要因素：

a = int(input("Enter a number: "))

def prime(a):
    b = list()
    i = 1
    while i<=a:
        if a%i ==0 and i!=1 and i!=a:
            b.append(i)
        i+=1
    return b

c = list()
for x in prime(a):
    if len(prime(x)) == 0:
        c.append(x)

print(c)

Answer 10

def prime_factors(num, dd=2):
    while dd <= num and num>1:
        if num % dd == 0:
            num //= dd
            yield dd
        dd +=1

上面的许多答案在小素数上都失败，例如3、5和7。以上内容简短且足够快，可以用于普通用途。

打印列表（prime_factors（3））

[3]

Answer 11

这是完成您所需要的有效方法：

def prime_factors(n): 
  l = []
  if n < 2: return l
  if n&1==0:
    l.append(2)
    while n&1==0: n>>=1
  i = 3
  m = int(math.sqrt(n))+1
  while i < m:
    if n%i==0:
      l.append(i)
      while n%i==0: n//=i
    i+= 2
    m = int(math.sqrt(n))+1
  if n>2: l.append(n)
  return l

prime_factors（198765430488765430290）= [2，3，5，7，11，11，13，19，23，3607，3803，52579]

Answer 12

您可以使用sieve Of Eratosthenes生成最多(n/2) + 1的所有素数，然后使用列表推导来获得所有素数因素：

def rwh_primes2(n):
    # http://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Input n>=6, Returns a list of primes, 2 <= p < n """
    correction = (n%6>1)
    n = {0:n,1:n-1,2:n+4,3:n+3,4:n+2,5:n+1}[n%6]
    sieve = [True] * (n/3)
    sieve[0] = False
    for i in xrange(int(n**0.5)/3+1):
      if sieve[i]:
        k=3*i+1|1
        sieve[      ((k*k)/3)      ::2*k]=[False]*((n/6-(k*k)/6-1)/k+1)
        sieve[(k*k+4*k-2*k*(i&1))/3::2*k]=[False]*((n/6-(k*k+4*k-2*k*(i&1))/6-1)/k+1)
    return [2,3] + [3*i+1|1 for i in xrange(1,n/3-correction) if sieve[i]]

def primeFacs(n):
    primes = rwh_primes2((n/2)+1)
    return [x for x in primes if n%x == 0]

print primeFacs(99999)
#[3, 41, 271]

Answer 13

def factorize(n):
  for f in range(2,n//2+1):
    while n%f == 0:
      n //= f
      yield f

它很慢但很简单。如果要创建命令行实用程序，可以执行以下操作：

import sys
[print(i) for i in factorize(int(sys.argv[1]))]

Answer 14

    from sets import Set
    # this function generates all the possible factors of a required number x
    def factors_mult(X):
        L = []
        [L.append(i) for i in range(2,X) if X % i == 0]
        return L

    # this function generates list containing prime numbers upto the required number x 
    def prime_range(X):
        l = [2]
        for i in range(3,X+1):
            for j in range(2,i):
               if i % j == 0:
               break
            else:    
               l.append(i)
        return l

    # This function computes the intersection of the two lists by invoking Set from the sets module
    def prime_factors(X):
        y = Set(prime_range(X))
        z = Set(factors_mult(X))
        k = list(y & z)
        k = sorted(k)

        print "The prime factors of " + str(X) + " is ", k

    # for eg
    prime_factors(356)

Answer 15

获得所需解决方案的简单方法

def Factor(n):
    d = 2
    factors = []
    while n >= d*d:
        if n % d == 0:
            n//=d
            # print(d,end = " ")
            factors.append(d)
        else:
            d = d+1
    if n>1:
        # print(int(n))
        factors.append(n)
    return factors

Answer 16

这是我制作的代码。对于具有小素数的数字，它可以正常工作，但对于素数为数百万的数字需要一段时间。

def pfactor(num):
div = 2
pflist = []
while div <= num:
    if num % div == 0:
        pflist.append(div)
        num /= div
    else:
        div += 1
# The stuff afterwards is just to convert the list of primes into an expression
pfex = ''
for item in list(set(pflist)):
    pfex += str(item) + '^' + str(pflist.count(item)) + ' * '
pfex = pfex[0:-3]
return pfex

素数分解 - 列表

16 个答案: