2013-02-09 108 views
0

下面我附上了素数因子分解的代码,它的工作原理。我只是想知道是否有任何方法可以使输出更清晰。我将主要因素添加到列表中,但递归结束时的最终列表包含列表列表,但我只需要一个包含数字的列表。素数因子实施

def prime_factor(n): 
    list = [] 
    if prime(n)==1: 
     list.append(n) 
     return list 
    else: 
     for i in range(2,n): 
      if n %i ==0: 
       a =prime_factor(i) 
       b = prime_factor(n/i) 
       list.extend(a) 
       list.extend(b) 
       return list 

def prime(n): 
    if n ==2 or n==3: 
     return 1 
    if n==1: 
     return 0 
    for i in range(2,n): 
     if n%i ==0: 
      return 0 
      break 
     if i ==n-1: 
      return 1 
      break 
+6

2和3不是唯一的素数。 – icktoofay 2013-02-09 22:20:32

+0

'prime(5 * 7)'给你什么? – 2013-02-09 22:22:17

+0

需要编辑素数方法 – phil12 2013-02-09 22:24:05

回答

1

你可以得到黄金的因素更容易:

def factorize(n): 
    factors = [] 

    p = 2 
    while True: 
     while(n % p == 0 and n > 0): #while we can divide by smaller number, do so 
      factors.append(p) 
      n = n/p 
     p += 1 #p is not necessary prime, but n%p == 0 only for prime numbers 
     if p > n/p: 
      break 
    if n > 1: 
     factors.append(n) 
    return factors 

print factorize(32*9*11*13*13) 

打印

[2,2,2,2,2,3,3,11,13,13]

您的解决方案可以改进为:

def prime_factor(n): 
    list = [] 
    if n==1: 
     return [1] #or []? 
    else: 
     for i in range(2,n+1): #additional improvement could be made here 
      if n %i ==0: 
       b = prime_factor(n/i) 
       list.append(i) #i is always prime in here, you return once first i is found 
       list.extend(b) 
       return list 

(你的def prime(n):困惑我,这是没有必要的)

+0

我想练习递归,所以我使用了递归方法 – phil12 2013-02-10 00:05:21

+0

行,但递归方法的执行速度较慢。尝试保理100000000或10000000000 – 2013-02-10 00:16:20

+0

有没有简单的方法来计算复杂性?我假设它是T(n)= n * T(n/i) – phil12 2013-02-10 00:38:15