Question

我必须创建一个函数来计算整数有多少因子。例如，当我致电factor(10)时，该功能应该能够告诉我它有4个因素（1，2，5，10）。那我从哪里开始呢？我需要放吗？

Answer 1

%（模数）运算符为您提供除法的余数。如果该余数为0，则第二个倍数是第二个倍数。因此，只需遍历从1到n的所有数字，然后检查它们是否是因素;如果是，请使用append将其添加到列表中：

def factors(n):
    result = []

    for i in range(1, n + 1):
        if n % i == 0:
            result.append(i)

    return result

Here's a demo.

或者，更简洁地使用lambdas：

def factors(n):
    return filter(lambda i: n % i == 0, range(1, n + 1))

Here's a demo.

Answer 2

对于小数字：

def factors(n):
    return [f for f in range(1,n+1) if n%f==0]

为了提高性能，如果您只对质数的数量感兴趣，可以找到素数分解。请参阅Wikipedia文章以查找此算法。一旦进行了素数分解，请注意每个数字都可以包含或排除。例如72 == 2^3 * 3^2。对于4 * 3 = 12种可能的组合，我们可以有0或1或2或3 3 s和0 or 1 or 2 3 s。（因子1对应于每组素数因子的0选择，数字本身对应于每组素数因子的最大选择。）

from functools import reduce  # needed in python3
from operators import *

def factors(n):
    primeFactors = prime_factorization_algorithm(n)
    # e.g. algorithm(72) == Counter({2:3, 3:2})

    return reduce(mul, (count+1 for factor,count in primeFactors.items()))

Answer 3

我认为测量仅在第一个sqrt(n)数字上执行模块的解决方案的性能可能是值得的。

def factors(n):
    sqrt = int(n ** .5)
    half_factors = [i for i in range(1, sqrt + 1) if n % i == 0]
    return half_factors + [n // i for i in half_factors[n%sqrt == 0::-1]]

快速测试：

>>> factors(16)
[1, 2, 4, 8, 16]
>>> factors(20)
[1, 2, 4, 10, 20]

注意：如果您使用的是Python 2，请将range更改为xrange，但请保留明确调用分部的//。

Answer 4

我使用此代码。它测试最多sqrt（n），跳过所有2和3的倍数。不那么慢...... 这个只返回素因子，而不是复合因素。

def factorize(n1):
    if n1==0: return []
    if n1==1: return [1]
    n=n1
    b=[]
    while n % 2 ==0 : b.append(2);n/=2
    while n % 3 ==0 : b.append(3);n/=3
    i=5
    inc=2
    while i*i<=n:
     while n % i ==0 : b.append(i); n/=i
     i+=inc
     inc=6-inc
    if n<>1:b.append(n) 
    return b

16位数整数：

>>> 
1234567890123456 [2, 2, 2, 2, 2, 2, 3, 7, 7, 301319, 435503] in  0.36825485272  seconds
>>>

Answer 5

你只需要从2 - sqrt（数字）除以找出它是否是复合的。因此，当你这样做时，每当一个数字除以时，你会得到两个因子，比如x和y，这样x * y =数字。现在，您可以编写一个递归因子函数，递归地查找数字，x和y的因子，最后返回没有重复的因子集（您必须找到一种方法来删除它们）。

Answer 6

import math
test = 3
p = [2]
#List of primes
correct = 0
limit = 100"""Set this to square root of number you are testing"""

while True:
    if test <= limit:
            if not test % p[correct - 1] == 0:
                correct = correct + 1
                if p[correct - 1] > test**0.5:
                    length = length + 1
                    correct = 0
                    p.append(test)
            else:
                test = test + 2
                correct = 0
    else:

        break
bt = int(input("Find factors of which number? "))
btt = bt
test_digit = 0
factors = []
num_factors = 1
factor_amount = 1
while True:
    if p[test_digit] < bt**0.5:
        if bt%p[test_digit] == 0:
            factors.append(p[test_digit])
            bt = bt / p[test_digit]
            factor_amount = factor_amount + 1
        else:
            test_digit = test_digit + 1
            if factor_amount > 1:
                num_factors = factor_amount * num_factors
                factor_amount = 1
    else:
        if bt > 1:
            factors.append(math.floor(bt))
            num_factors = num_factors * 2
        break
print(btt,"has",num_factors,"which are",factors)
    else:
        break

这应该找出主要因素和它有多少独特因素。

Answer 7

def num_divisors(num):
    factors = list(filter(lambda i: num%i == 0, range(1,int(num/2)+1)))
    return len(factors) + 1

filter()函数本身不会产生可见的数组（它返回迭代器），因此为什么我使用了list()函数。我们之所以返回len(factors) + 1是因为为了节省执行时间，我们只发现了不超过原始数值一半的因子。所以我们错过了数字本身，因此我们加了1。

整数中有多少个因子

7 个答案: