Python：数字中的素数答案

【问题标题】：Python : Primes in numbersPython：数字中的素数
【发布时间】：2017-12-03 11:28:52
【问题描述】：

给定一个正数 n > 1，求 n 的素因子分解。结果将是一个格式如下的字符串：

"(p1**n1)(p2**n2)...(pk**nk)"

p(i) 以递增的顺序排列，如果 n(i) 为 1，则 n(i) 为空。

示例：n = 86240 应返回 "(2**5)(5)(7**2)(11)"

这是我的代码，但我对 n>250000 的时间有问题

def primeFactors(n):
    a=""
    i=2
    while i<=n:
        #part of identifying if number i is prime
        w1=5
        w2=2
        gg=0
        while w1*w1<=i:
            if i%w1==0:
                gg=1
                break
            w1+=w2
            w2=6-w2
        #checking if previous loop has been broken
         if gg:
            i+=1
            continue
        #countig how many thimes we can divide n on i
        c=0
        for j in range(1,n):
            if n%i!=0: break
            c+=1
            n=n//i
        #if we can divide n on i only once
        if c==1:
            a+="("+str(i)+")"
        elif c>1:
            a+="("+str(i)+"**"+str(c)+")"
        i+=1
    return a

有没有办法解决这个问题？

【问题讨论】：

能否请您修复代码中条件子句和循环的缩进？目前我们很难猜测每个子句应该在哪里结束......
你遇到了什么问题？
时间问题
你必须更加明确。你的意思是太长了？多长时间？
检查 i 的素数可能是浪费时间。只需首先检查 2 或 3 是否为因数，然后尝试 i = 5、7、11、13、17、19... 之后，在 1 和 -1 mod 6 之间交替。保证成功的 i 值成为素数（练习留给读者）。最大的改进可能来自将测试while i<=n 替换为while i<=n**0.5。

标签： python python-3.x primes

【解决方案1】：

问题不在于程序所做的素因数分解，而是让 Python 在非常短的时间内完成非常大的数字。具体来说，我的理解是我们需要能够计算：

for n in range(10 ** 9, 10 ** 9 + 10):
    print(n, '=', primeFactors(n))

10 ** 9 + 4。我对您的代码的第一印象是您需要将主要逻辑与其余代码分开，使其易于理解，然后清理和优化代码的两个部分。我重写了你的程序：

def generate_primes(n):

    """ generate real primes """

    yield(2)

    primes = [(2, 4)]

    for m in range(3, n, 2):

        for prime, square in primes:

            if square > m:
                yield(m)
                primes.append((m, m * m))
                break

            if m % prime == 0:
                break

def primeFactors(n):
    string = ""
    i = 2

    for i in generate_primes(int(n ** 0.5) + 1):

        # counting how many times we can divide n on i
        c = 0

        while True:
            product, remainder = divmod(n, i)

            if remainder != 0:
                break

            n = product
            c += 1

        # if we can divide n on i only once
        if c == 1:
            string += f"({i})"
        elif c > 1:
            string += f"({i}**{c})"

    if n > 1:  # final prime factor greater than square root
        string += f"({n})"

    return string

我换了一个素数生成器以避免冗余计算。这个优化版本可以达到上述测试中每个大数的 32ms。还是不够好。所以让我们试试@JamesKPolk 的建议并使用伪素数：

def generate_primes(n):

    """ generate 5-rough pseudoprimes """

    if n >= 2:
        yield(2)

    if n >= 3:
        yield(3)

    if n >= 5:
        m = 1
        x = 4

        while m < n:
            m += x
            yield(m)
            x = 6 - x

这里的权衡是我们将测试比我们真正需要的更多的除数，但我们可以更快地生成这些除数很多。无论如何，此更改在我的机器上实现了我们的目标，即每个大数因子

输出

> time python3 test.py
1000000000 = (2**9)(5**9)
1000000001 = (7)(11)(13)(19)(52579)
1000000002 = (2)(3)(43)(983)(3943)
1000000003 = (23)(307)(141623)
1000000004 = (2**2)(41**2)(148721)
1000000005 = (3)(5)(66666667)
1000000006 = (2)(500000003)
1000000007 = (1000000007)
1000000008 = (2**3)(3**2)(7)(109**2)(167)
1000000009 = (1000000009)
0.106u 0.010s 0:00.11 100.0%    0+0k 0+0io 0pf+0w
>

【讨论】：