Question

下面的算法是我用Python实现的Eratosthenes的Sieve。该算法查找直到给定值的第一个素数，即n。

此算法的工作方式是打印从2到n的所有素数。我想要做的是另一种方式，即从n开始向下到m，或者一些随机切片，例如最大的100个数字。因此，例如..如果我有一个巨大的数字（例如2亿），我将能够从2亿打印最大的100个素数（不是来自200亿的PRIME数字，但是这是一个等于/少的原则超过2亿！）。

有人可以帮忙吗？

def primes(n):    
    array = [i for i in range(2,n+1)] 
    p = 2 

    while p <= n:
        i = 2*p
        while i <= n:
            array[i-2] = 0
            i += p
        p += 1  

    return [num for num in array if num > 0]

Answer 1

以这种方式：

def largest_primes_under(number, cap):
    n = cap - 1
    while number and n >= 2:
        if all(n % d for d in range(2, int(n ** 0.5 + 1))):
            yield n
            number -= 1
        n -= 1

演示：

for p in largest_primes_under(10, 10**9):
    print(p)

输出：

Answer 2

这是我在评论中链接的范围筛选程序的修改版本。它使用prime number theorem得到hi附近素数密度的近似值，并使用该密度估算lo，使得range(lo, hi)＆gt; = {中的素数数量{1}}。有关详细信息，请参阅Prime Counting Function上的Mathworld文章。

通常，没有简单的方法来准确估计给定范围内的素数。 FWIW，在特殊情况下，很容易证明给定范围内没有素数，例如num中的每个数字都可以被range(n! + 2, n! + n + 1)中的数字整除。

下面的代码（希望:)）高估了所需的范围。但是我们不希望它使用range(2, n + 1)的值太低而浪费时间。在某些情况下，lo不够小，特别是当lo非常小时，但如果您使用num的合理值，则应该没问题。

num

使用

#! /usr/bin/env python

''' Prime range sieve.

    Written by PM 2Ring 2014.10.15

    2015.05.24 Modified to find the `num` highest primes < `hi` 
'''

import sys
from math import log

def potential_primes():
    ''' Make a generator for 2, 3, 5, & thence all numbers coprime to 30 '''
    s = (2, 3, 5, 7, 11, 13, 17, 19, 23, 29)
    for i in s:
        yield i
    s = (1,) + s[3:] 
    j = 30
    while True:
        for i in s:
            yield j + i
        j += 30


def range_sieve(lo, hi):
    ''' Create a list of all primes in the range(lo, hi) '''

    #Mark all numbers as prime
    primes = [True] * (hi - lo)

    #Eliminate 0 and 1, if necessary
    for i in range(lo, min(2, hi)):
        primes[i - lo] = False

    ihi = int(hi ** 0.5)
    for i in potential_primes():
        if i > ihi: 
            break

        #Find first multiple of i: i >= i*i and i >= lo
        ilo = max(i, 1 + (lo - 1) // i ) * i

        #Determine how many multiples of i >= ilo are in range
        n = 1 + (hi - ilo - 1) // i

        #Mark them as composite
        primes[ilo - lo : : i] = n * [False]

    return [i for i,v in enumerate(primes, lo) if v]


def main():
    hi = int(sys.argv[1]) if len(sys.argv) > 1 else 1000000
    num = int(sys.argv[2]) if len(sys.argv) > 2 else 1000

    #Estimate required range using the prime number theorem
    #The constant 1.25506 is from the MathWorld article on
    #the Prime Counting Function
    d = num * log(hi) * 1.25506

    #An alternate estimator. Sometimes estimates a little too low. 
    #d = num * (log(hi) + log(log(hi)))

    lo = max(2, hi - int(d))
    print 'lo =', lo

    primes = range_sieve(lo, hi)
    print len(primes), 'primes found'

    for i, p in enumerate(reversed(primes[-num:]), 1): print '%2d: %d' % (i, p)


if __name__ == '__main__':
    main()

调用

输出

$ python range_sieve.py 1234567890 60

Answer 3

没有运行代码。它应该工作，但需要改变。我刚发布它给你直觉。

def primes(n):    
    array = [1 for i in range(0,n)]
    array[0] = 0
    array[1] = 0 
    p = 2 
    while p <= n:
        i = 2*p
        while i <= n:
            array[i] = 0
            i += p
        p += 1
        while (array[p] == 0):
            p += 1 
    result = [] 
    i = 0
    while i <= n:
        if array[i]==1:
            result.append(i)
        i += 1
    return result

Answer 4

def primes(n):
    p = n/2
    return (n%i for i in range(2, p+1))

def test_primes(n, n_largest):
    ret = (k for k in range(n, 0, -1) if all(primes(k)))
    return [ret.next() for v in range(n_largest)]

使用

>>print test_primes(20, 2)
[17, 19]

获取

下的n个最大数字

功能＆＃34;素数＆＃34;得到一个元素的其余部分由所有元素小于其中间部分然后＆＃34; test_primes＆＃34;测试所有的休息是否为0。如果所有的休止符都不是0那么这个元素是素数，所以我们打印它

找到m下的n个最大素数

4 个答案: