这是非常愚蠢的方式：
4def divisorGenerator(n):
for i in xrange(1,n/2+1):
if n%i == 0: yield i
yield n我想得到的结果和这个相似，但我想要一个更聪明的算法(这个算法太慢太笨了：-)
我可以很快找到基本因子及其多重性。我有一个发生器，它以这种方式产生因子：
(系数1，乘数1)(系数2，倍数2)(系数3，倍数3)等等……
即输出
2for i in factorGenerator(100):
print i号
是：
2(2, 2)
(5, 2)我不知道这对我想做的事情有多有用(我为其他问题编码了它)，不管怎样，我想要一个更聪明的方法
2for i in divisorGen(100):
print i。
输出此：
更新：非常感谢Greg Hewgill和他的"聪明的方式"：)计算100000000的除数时，他用0.01秒的速度计算了我机器上的39秒，非常酷：d
更新2：不要说这是这篇文章的副本。计算一个给定数的除数不需要计算所有的除数。这是一个不同的问题，如果你认为不是，那么在维基百科上寻找"除数函数"。在发帖前阅读问题和答案，如果你不理解主题是什么，不要添加不有用的和已经给出的答案。
之所以有人认为这个问题几乎是"计算给定数字除数的算法"的一个副本，是因为在这个问题中，建议的第一步是找到所有的除数，我相信这正是你想做的？
安德鲁为了找到有多少个除数，你只需要找到素数，然后用它们来计算可能有多少个除数。在这种情况下不需要求除数。
@Andrea Ambu，请更正您的函数名
考虑到factorgenerator函数，这里有一个除数器应该工作：
15def divisorGen(n):
factors = list(factorGenerator(n))
nfactors = len(factors)
f = [0] * nfactors
while True:
yield reduce(lambda x, y: x*y, [factors[x][0]**f[x] for x in range(nfactors)], 1)
i = 0
while True:
f[i] += 1
if f[i] <= factors[i][1]:
break
f[i] = 0
i += 1
if i >= nfactors:
return该算法的整体效率完全取决于因子发生器的效率。
哇，用0.01来计算所有的除数100000000，而用了39个愚蠢的方式(停在n/2)，非常酷，谢谢！
对于我们这些不懂Python的人来说，这到底在做什么？
一氧化碳：计算给定因子的所有乘法组合。其中大部分应该是不言自明的，"收益"线就像一个收益，但在返回一个值之后会继续。[0]*NFactors创建长度为零的NFactors列表。reduce(…)计算因子的乘积。
reduce和lambda符号实际上让我困惑。我尝试在C语言中实现一种算法，使用递归函数遍历因子数组并将它们相乘，但对于具有许多因子的1024这样的数字，它的性能似乎很糟糕。
为什么不使用operator.mul？
@Speckiniusflecksis：没有理由，operator.mul在那里也同样有效。
当然，这比将每个数除以n/2甚至sqrt(n)要好得多，但是这种特殊的实现有两个缺点：非常内敛：成吨的乘法和求幂运算，重复地乘以相同的幂次等等。这看起来像Python，但我不认为Python是在扼杀性能。问题二：除数没有按顺序返回。
谢谢格雷格。您的算法激发了我在这里更实用的版本：rosettacode.org/wiki/proper_divisions python：_prime_fact&zwnj；&8203；ors
代码产生错误，TypeError: 'int' object has no attribute '__getitem__'，向下投票
@Greghewgill是的，我也会得到一个_TypeError: 'int' object has no attribute '__getitem__'错误。它是可解的吗？
未解析的引用"reduce"。我应该进口什么？功能工具？
为了扩展Shimi所说的内容，您应该只运行从1到n的平方根的循环，然后找到这对，执行n / i，这将覆盖整个问题空间。
如前所述，这是一个NP或"困难"问题。详尽的搜索，你做它的方式，差不多是它得到的保证的答案。加密算法等使用这个事实来帮助保护它们。如果有人要解决这个问题，大多数(如果不是全部)我们当前的"安全"通信都会变得不安全。
python代码：
13import math
def divisorGenerator(n):
large_divisors = []
for i in xrange(1, int(math.sqrt(n) + 1)):
if n % i == 0:
yield i
if i*i != n:
large_divisors.append(n / i)
for divisor in reversed(large_divisors):
yield divisor
print list(divisorGenerator(100))它应该输出如下列表：
1[1, 2, 4, 5, 10, 20, 25, 50, 100]号
因为，一旦你有了1到10之间的元素列表，你就可以生成11到100之间的任何元素。你得到1，2，4，5，10。将100除以这些元素中的每一个，就可以得到100、50、20、25、10。
根据定义，因子总是成对生成的。通过只搜索sqrt(n)，你的工作被一个2次方切断了。
它比我文章中的版本快得多，但比使用基本因子的版本慢得多
我同意这不是最好的解决办法。我只是简单地指出了一种"更好"的搜索方式，这种方式可以节省很多时间。
因子分解并不是NP硬的。en.wikipedia.org/wiki/integer_factorization的问题是找到所有除数，因为已经找到了基本因子(硬因子)。
这意味着因子分解是一种扩展的NP硬算法。事实上，他们已经有了主要因素，这一点无关紧要。给出的例子是详尽的搜索，这是缓慢和困难的。
如果我不是N/I：应该是如果我！=n/i:，对于平方根大于256'is'的值将不起作用。
对于小数字，它比使用质数因子的版本快得多。
很好的回答
我想你可以停在江户一号〔4〕而不是2号。
我给你举个例子，这样你就容易理解了。现在，sqrt(28)是5.29，所以ceil(5.29)将是6。所以如果我在6点停下来，我就能得到所有的除数。怎么用？
首先看到代码，然后看到图像：
8import math
def divisors(n):
divs = [1]
for i in xrange(2,int(math.sqrt(n))+1):
if n%i == 0:
divs.extend([i,n/i])
divs.extend([n])
return list(set(divs))号
现在，请参见下图：
假设我已经将1添加到除数列表中，我从i=2开始。
。
所以在所有迭代的末尾，当我把商和除数添加到我的列表中时，28的所有除数都被填充了。
来源：如何确定一个数的除数
很好，很好！！math.sqrt(n) instead of n/2是优雅的必备品
这是不正确的。你忘了n是可以被它自己整除的。
回答得很好。简单明了。但对于python 3，有两个必要的更改：n/i应该使用int(n/i)键入，因为n/i产生浮点数。另外，在python 3中，rangex已被弃用，并已被range替换。
虽然已经有很多解决方案，但我真的要发布这个：)
这个是：
可读性
短的
独立、复制和粘贴就绪
快速(在有很多素数因子和除数的情况下，比公认的解快10倍以上)
python3、python2和pypy兼容
代码：
32def divisors(n):
# get factors and their counts
factors = {}
nn = n
i = 2
while i*i <= nn:
while nn % i == 0:
factors[i] = factors.get(i, 0) + 1
nn //= i
i += 1
if nn > 1:
factors[nn] = factors.get(nn, 0) + 1
primes = list(factors.keys())
# generates factors from primes[k:] subset
def generate(k):
if k == len(primes):
yield 1
else:
rest = generate(k+1)
prime = primes[k]
for factor in rest:
prime_to_i = 1
# prime_to_i iterates prime**i values, i being all possible exponents
for _ in range(factors[prime] + 1):
yield factor * prime_to_i
prime_to_i *= prime
# in python3, `yield from generate(0)` would also work
for factor in generate(0):
yield factor号
我会用while i <= limit代替while i*i <= nn，其中limit = math.sqrt(n)
我喜欢Greg解决方案，但我希望它更像Python。我觉得它会更快更易读；经过一段时间的编码之后，我发现了这个。
前两个函数用于生成列表的笛卡尔积。并且可以在不出现此问题的情况下重复使用。顺便说一下，我必须自己编写这个程序，如果有人知道这个问题的标准解决方案，请随时与我联系。
"factorgenerator"现在返回字典。然后字典被输入"除数"，除数首先用来生成一个列表列表，其中每个列表都是p^n和p prime形式的因子列表。然后我们得到这些列表的笛卡尔积，最后用格雷格解生成除数。我们把它们分类，然后把它们退回。
我测试过它，它似乎比以前的版本快一点。我把它作为一个更大程序的一部分进行了测试，所以我不能说它到底快了多少。
Pietro Speroni(Pietrosperoni点状)
69from math import sqrt
##############################################################
### cartesian product of lists ##################################
##############################################################
def appendEs2Sequences(sequences,es):
result=[]
if not sequences:
for e in es:
result.append([e])
else:
for e in es:
result+=[seq+[e] for seq in sequences]
return result
def cartesianproduct(lists):
"""
given a list of lists,
returns all the possible combinations taking one element from each list
The list does not have to be of equal length
"""
return reduce(appendEs2Sequences,lists,[])
##############################################################
### prime factors of a natural ##################################
##############################################################
def primefactors(n):
'''lists prime factors, from greatest to smallest'''
i = 2
while i<=sqrt(n):
if n%i==0:
l = primefactors(n/i)
l.append(i)
return l
i+=1
return [n] # n is prime
##############################################################
### factorization of a natural ##################################
##############################################################
def factorGenerator(n):
p = primefactors(n)
factors={}
for p1 in p:
try:
factors[p1]+=1
except KeyError:
factors[p1]=1
return factors
def divisors(n):
factors = factorGenerator(n)
divisors=[]
listexponents=[map(lambda x:k**x,range(0,factors[k]+1)) for k in factors.keys()]
listfactors=cartesianproduct(listexponents)
for f in listfactors:
divisors.append(reduce(lambda x, y: x*y, f, 1))
divisors.sort()
return divisors
print divisors(60668796879)。
附笔。这是我第一次向StackOverflow发帖。我期待任何反馈。
在python 2.6中有一个itertools.product()。
使用生成器而不是list.append everywhere的版本可能更干净。
埃拉托森筛可用于生成小于或等于sqrt(n)stackoverflow.com/questions/188425/project euler problem 193&zwnj；&8203；605的素数。
编码样式：指数=[k**x代表k，v代表factors.items()代表x代表范围(v+1)]
对于ListExponents：【k**x表示范围内的x(v+1)】表示k，v表示factors.items()]
改编自codereview，这里有一个与num=1一起工作的变体！
17from itertools import product
import operator
def prod(ls):
return reduce(operator.mul, ls, 1)
def powered(factors, powers):
return prod(f**p for (f,p) in zip(factors, powers))
def divisors(num) :
pf = dict(prime_factors(num))
primes = pf.keys()
#For each prime, possible exponents
exponents = [range(i+1) for i in pf.values()]
return (powered(primes,es) for es in product(*exponents))我好像犯了一个错误：NameError: global name 'prime_factors' is not defined。其他答案和最初的问题都不能定义这是什么。
我只想添加一个稍微修改过的版本的anivarth(我相信这是最Python)供将来参考。
8from math import sqrt
def divisors(n):
divs = {1,n}
for i in range(2,int(sqrt(n))+1):
if n%i == 0:
divs.update((i,n//i))
return divs在纯Python3.6中，对于10*16及以下的数字，这是一种智能且快速的方法，
33from itertools import compress
def primes(n):
""" Returns a list of primes < n for n > 2"""
sieve = bytearray([True]) * (n//2)
for i in range(3,int(n**0.5)+1,2):
if sieve[i//2]:
sieve[i*i//2::i] = bytearray((n-i*i-1)//(2*i)+1)
return [2,*compress(range(3,n,2), sieve[1:])]
def factorization(n):
""" Returns a list of the prime factorization of n"""
pf = []
for p in primeslist:
if p*p > n : break
count = 0
while not n % p:
n //= p
count += 1
if count > 0: pf.append((p, count))
if n > 1: pf.append((n, 1))
return pf
def divisors(n):
""" Returns an unsorted list of the divisors of n"""
divs = [1]
for p, e in factorization(n):
divs += [x*p**k for k in range(1,e+1) for x in divs]
return divs
n = 600851475143
primeslist = primes(int(n**0.5)+1)
print(divisors(n))号
用来寻找素数和进行因式分解的算法的名称是什么？因为我想在C中实现这个。
老问题，但我的看法是：
4def divs(n, m):
if m == 1: return [1]
if n % m == 0: return [m] + divs(n, m - 1)
return divs(n, m - 1)您可以代理：
3def divisorGenerator(n):
for x in reversed(divs(n, n)):
yield x。
注意：对于支持的语言，这可能是尾部递归。
如果你只关心使用列表理解，而对你来说没有其他重要的东西！
8from itertools import combinations
from functools import reduce
def get_devisors(n):
f = [f for f,e in list(factorGenerator(n)) for i in range(e)]
fc = [x for l in range(len(f)+1) for x in combinations(f, l)]
devisors = [1 if c==() else reduce((lambda x, y: x * y), c) for c in set(fc)]
return sorted(devisors)号
这是我的解决方案。它看起来很蠢，但效果很好……我试图找到所有合适的除数，所以循环从i=2开始。
11import math as m
def findfac(n):
faclist = [1]
for i in range(2, int(m.sqrt(n) + 2)):
if n%i == 0:
if i not in faclist:
faclist.append(i)
if n/i not in faclist:
faclist.append(n/i)
return facts。
假设factors函数返回n的因子(例如，factors(60)返回列表[2，2，3，5])，这里有一个函数来计算n的除数：
9function divisors(n)
divs := [1]
for fact in factors(n)
temp := []
for div in divs
if fact * div not in divs
append fact * div to temp
divs := divs + temp
return divs。
那是Python吗？无论如何，它肯定不是python 3.x。
它是伪代码，应该很容易翻译成python。
迟了3年，总比不迟好：)我认为这是最简单、最短的代码。我没有一个比较表，但是我可以在i5笔记本电脑上分解和计算一百万分之一秒的除数。
对我来说，这很好，也很干净(python 3)
9def divisors(number):
n = 1
while(n
if(number%n==0):
print(n)
else:
pass
n += 1
print(number)不是很快，但可以按需要逐行返回除数，也可以执行list.append(n)和list.append(number)操作
你读过手术室提议的非常愚蠢的方式吗？
1return [x for x in range(n+1) if n/x==int(n/x)]。
提问者要求更好的算法，而不仅仅是更漂亮的格式。
您需要使用范围(1，n+1)来避免被零除。另外，如果使用python 2.7，那么第一个除法需要使用float(n)，这里1/2=0
