Python Eratosthenes Sieve 算法优化

Question

我正在尝试实施埃拉托色尼筛法。输出似乎是正确的（减去需要添加的“2”），但如果函数的输入大于 100k 左右，它似乎需要过多的时间。我可以通过哪些方式优化此功能？

def sieveErato(n):
     numberList = range(3,n,2)

     for item in range(int(math.sqrt(len(numberList)))):
            divisor = numberList[item]
            for thing in numberList:
                    if(thing % divisor == 0) and thing != divisor:
                            numberList.remove(thing)
    return numberList

Answer 1

你可以尝试埃拉托色尼的方法。取一个包含所有数字的数组，以检查升序，转到数字 2 并标记它。现在每隔一个数字刮一次，直到数组结束。然后转到3并标记它。之后每三号刮一次。然后转到 4 - 它已经被划伤了，所以跳过它。对每个尚未划伤的 n+1 重复此操作。

最后，标记的数字是质数。此算法速度更快，但有时需要大量内存。您可以通过删除所有偶数（因为它们不是素数）并手动将 2 添加到列表中来对其进行一些优化。这会稍微扭曲逻辑，但会占用一半的内存。

这是我在说什么的插图：http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes

Answer 2

警告：在迭代时从迭代器中删除元素可能是危险的......

你可以做

    if(thing % divisor == 0) and thing != divisor:

通过在到达“除数”索引然后测试时中断的循环中拆分它来测试更轻：

for thing in numberList_fromDivisorOn:
    if(thing % divisor == 0):
        numberList.remove(thing)

Answer 3

我按照@MAK 的建议点击了这个链接：Sieve of Eratosthenes - Finding Primes Python，我发现可以通过我在您的代码中找到的想法来改进接受的答案：

def primes_sieve2(limit):
    a = [True] * limit               # Initialize the primality list
    a[0] = a[1] = False
    sqrt = int(math.sqrt(limit))+1
    for i in xrange(sqrt):
        isprime = a[i]
        if isprime:
            yield i
            for n in xrange(i*i, limit, i):     # Mark factors non-prime
                a[n] = False
    for (i, isprime) in enumerate(a[sqrt:]):
        if isprime:
            yield i+sqrt

Answer 4

如果给定无限的内存和时间，以下代码将打印所有质数。它会在不使用试用部门的情况下完成。它基于论文中的haskell代码：The Genuine Sieve of Eratosthenes by Melissa E. O'Neill

from heapq import heappush, heappop, heapreplace
def sieve():
    w = [2,4,2,4,6,2,6,4,2,4,6,6,2,6,4,2,6,4,6,8,4,2,4,2,4,8,6,4,6,2,4,6,2,6,6,4,2,4,6,2,6,4,2,4,2,10,2,10]
    for p in [2,3,5,7]: print p
    n,o = 11,0
    t = []
    l = len(w)
    p = n
    heappush(t, (p*p, n,o,p))
    print p
    while True:
        n,o = n+w[o],(o+1)%l
        p = n
        if not t[0][0] <= p:
            heappush(t, (p*p, n,o,p))
            print p
            continue
        while t[0][0] <= p:
            _, b,c,d = t[0]
            b,c = b+w[c],(c+1)%l
            heapreplace(t, (b*d, b,c,d))
sieve()

Answer 5

您的算法不是埃拉托色尼筛法。您执行试除法（模数运算符）而不是像埃拉托色尼在两千多年前所做的那样交叉倍数。 Here 是对真正筛分算法的解释，下面是我简单直接的实现，它返回一个不超过 n 的素数列表：

def sieve(n):
    m = (n-1) // 2
    b = [True]*m
    i,p,ps = 0,3,[2]
    while p*p < n:
        if b[i]:
            ps.append(p)
            j = 2*i*i + 6*i + 3
            while j < m:
                b[j] = False
                j = j + 2*i + 3
        i+=1; p+=2
    while i < m:
        if b[i]:
            ps.append(p)
        i+=1; p+=2
    return ps

我们只筛选奇数，在 n 的平方根处停止。 j 上看起来很奇怪的计算映射在被筛选的整数 3、5、7、9、... 和 b 中的索引 0、1、2、3、... 之间 位数组。

您可以在 http://ideone.com/YTaMB 看到这个函数的运行情况，它可以在不到一秒的时间内计算出一百万个素数。

Answer 6

此代码需要 2 秒才能生成小于 10M 的素数 （不是我的，我在 google 上找到的）

def erat_sieve(bound):
    if bound < 2:
        return []
    max_ndx = (bound - 1) // 2
    sieve = [True] * (max_ndx + 1)
    #loop up to square root
    for ndx in range(int(bound ** 0.5) // 2):
        # check for prime
        if sieve[ndx]:
            # unmark all odd multiples of the prime
            num = ndx * 2 + 3
            sieve[ndx+num:max_ndx:num] = [False] * ((max_ndx-ndx-num-1)//num + 1)
    # translate into numbers
    return [2] + [ndx * 2 + 3 for ndx in range(max_ndx) if sieve[ndx]]