Python 中的简单素数生成器[重复]
- 2024-12-30 08:42:00
- admin 原创
- 142
问题描述：
有人能告诉我这段代码哪里出错了吗？反正它只是打印“count”。我只想要一个非常简单的素数生成器（没什么特别的）。
import math
def main():
count = 3
one = 1
while one == 1:
for x in range(2, int(math.sqrt(count) + 1)):
if count % x == 0:
continue
if count % x != 0:
print count
count += 1
解决方案 1：
存在一些问题：
为什么当 count 不能被 x 整除时，会打印出 count？这并不意味着它是素数，而只是意味着这个特定的 x 不能整除它
continue移动到下一个循环迭代 - 但你真的想使用break
这是经过一些修复的代码，它只打印出素数：
import math
def main():
count = 3
while True:
isprime = True
for x in range(2, int(math.sqrt(count) + 1)):
if count % x == 0:
isprime = False
break
if isprime:
print count
count += 1
对于更高效的素数生成，请参阅其他人建议的埃拉托斯特尼筛法。这是一个不错的优化实现，带有许多注释：
# Sieve of Eratosthenes
# Code by David Eppstein, UC Irvine, 28 Feb 2002
# http://code.activestate.com/recipes/117119/
def gen_primes():
""" Generate an infinite sequence of prime numbers.
"""
# Maps composites to primes witnessing their compositeness.
# This is memory efficient, as the sieve is not "run forward"
# indefinitely, but only as long as required by the current
# number being tested.
#
D = {}
# The running integer that's checked for primeness
q = 2
while True:
if q not in D:
# q is a new prime.
# Yield it and mark its first multiple that isn't
# already marked in previous iterations
#
yield q
D[q * q] = [q]
else:
# q is composite. D[q] is the list of primes that
# divide it. Since we've reached q, we no longer
# need it in the map, but we'll mark the next
# multiples of its witnesses to prepare for larger
# numbers
#
for p in D[q]:
D.setdefault(p + q, []).append(p)
del D[q]
q += 1
请注意，它返回一个生成器。
解决方案 2：
re 功能强大：
import re
def isprime(n):
return re.compile(r'^1?$|^(11+)+$').match('1' * n) is None
print [x for x in range(100) if isprime(x)]
###########Output#############
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
解决方案 3：
def is_prime(num):
"""Returns True if the number is prime
else False."""
if num == 0 or num == 1:
return False
for x in range(2, num):
if num % x == 0:
return False
else:
return True
>> filter(is_prime, range(1, 20))
[2, 3, 5, 7, 11, 13, 17, 19]
我们将在一个列表中获取所有不超过 20 的素数。我本可以使用埃拉托斯特尼筛法，但你说你想要一些非常简单的东西。;)
解决方案 4：
def primes(n): # simple sieve of multiples
odds = range(3, n+1, 2)
sieve = set(sum([list(range(q*q, n+1, q+q)) for q in odds], []))
return [2] + [p for p in odds if p not in sieve]
>>> primes(50)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
测试一个数字是否为质数：
>>> 541 in primes(541)
True
>>> 543 in primes(543)
False
解决方案 5：
print [x for x in range(2,100) if not [t for t in range(2,x) if not x%t]]
解决方案 6：
SymPy是一个用于符号数学的 Python 库。它提供了几个生成素数的函数。
isprime(n) # Test if n is a prime number (True) or not (False).
primerange(a, b) # Generate a list of all prime numbers in the range [a, b).
randprime(a, b) # Return a random prime number in the range [a, b).
primepi(n) # Return the number of prime numbers less than or equal to n.
prime(nth) # Return the nth prime, with the primes indexed as prime(1) = 2. The nth prime is approximately n*log(n) and can never be larger than 2**n.
prevprime(n, ith=1) # Return the largest prime smaller than n
nextprime(n) # Return the ith prime greater than n
sieve.primerange(a, b) # Generate all prime numbers in the range [a, b), implemented as a dynamically growing sieve of Eratosthenes.
以下是一些示例。
>>> import sympy
>>>
>>> sympy.isprime(5)
True
>>> list(sympy.primerange(0, 100))
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
>>> sympy.randprime(0, 100)
83
>>> sympy.randprime(0, 100)
41
>>> sympy.prime(3)
5
>>> sympy.prevprime(50)
47
>>> sympy.nextprime(50)
53
>>> list(sympy.sieve.primerange(0, 100))
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]
解决方案 7：
这是一个简单的（Python 2.6.2）解决方案......它符合 OP 的原始请求（现在已经六个月了）；并且应该是任何“编程 101”课程中完全可以接受的解决方案......因此有这篇文章。
import math
def isPrime(n):
for i in range(2, int(math.sqrt(n)+1)):
if n % i == 0:
return False;
return n>1;
print 2
for n in range(3, 50):
if isPrime(n):
print n
这种简单的“蛮力”方法在现代 PC 上对于大约 16,000 的数字来说“足够快”（在我的 2GHz 机器上大约花费 8 秒）。
显然，这可以更有效地完成，通过不重新计算每个偶数的素数，或者每个数字的 3、5、7 等的倍数...请参阅埃拉托斯特尼筛选法（参见上面 eliben 的实现），或者如果你觉得自己特别勇敢和/或疯狂，甚至可以使用阿特金筛选法。
买者自慎：我是 Python 菜鸟。请不要将我说的任何话视为真理。
解决方案 8：
这是埃拉托斯特尼筛法的 numpy 版本，具有不错的复杂度（低于对长度为 n 的数组进行排序）和矢量化。
import numpy as np
def generate_primes(n):
is_prime = np.ones(n+1,dtype=bool)
is_prime[0:2] = False
for i in range(int(n**0.5)+1):
if is_prime[i]:
is_prime[i*2::i]=False
return np.where(is_prime)[0]
时间安排：
import time
for i in range(2,10):
timer =time.time()
generate_primes(10**i)
print('n = 10^',i,' time =', round(time.time()-timer,6))
>> n = 10^ 2 time = 5.6e-05
>> n = 10^ 3 time = 6.4e-05
>> n = 10^ 4 time = 0.000114
>> n = 10^ 5 time = 0.000593
>> n = 10^ 6 time = 0.00467
>> n = 10^ 7 time = 0.177758
>> n = 10^ 8 time = 1.701312
>> n = 10^ 9 time = 19.322478
解决方案 9：
另一个简单的例子，进行了简单的优化，只考虑奇数。一切都用惰性流（python 生成器）完成。
用法： primes = list(create_prime_iterator(1, 30))
import math
import itertools
def create_prime_iterator(rfrom, rto):
"""Create iterator of prime numbers in range [rfrom, rto]"""
prefix = [2] if rfrom < 3 and rto > 1 else [] # include 2 if it is in range separately as it is a "weird" case of even prime
odd_rfrom = 3 if rfrom < 3 else make_odd(rfrom) # make rfrom an odd number so that we can skip all even nubers when searching for primes, also skip 1 as a non prime odd number.
odd_numbers = (num for num in xrange(odd_rfrom, rto + 1, 2))
prime_generator = (num for num in odd_numbers if not has_odd_divisor(num))
return itertools.chain(prefix, prime_generator)
def has_odd_divisor(num):
"""Test whether number is evenly divisable by odd divisor."""
maxDivisor = int(math.sqrt(num))
for divisor in xrange(3, maxDivisor + 1, 2):
if num % divisor == 0:
return True
return False
def make_odd(number):
"""Make number odd by adding one to it if it was even, otherwise return it unchanged"""
return number | 1
解决方案 10：
刚刚研究了这个主题，在线程中查找示例并尝试制作我的版本：
from collections import defaultdict
# from pprint import pprint
import re
def gen_primes(limit=None):
"""Sieve of Eratosthenes"""
not_prime = defaultdict(list)
num = 2
while limit is None or num <= limit:
if num in not_prime:
for prime in not_prime[num]:
not_prime[prime + num].append(prime)
del not_prime[num]
else: # Prime number
yield num
not_prime[num * num] = [num]
# It's amazing to debug it this way:
# pprint([num, dict(not_prime)], width=1)
# input()
num += 1
def is_prime(num):
"""Check if number is prime based on Sieve of Eratosthenes"""
return num > 1 and list(gen_primes(limit=num)).pop() == num
def oneliner_is_prime(num):
"""Simple check if number is prime"""
return num > 1 and not any([num % x == 0 for x in range(2, num)])
def regex_is_prime(num):
return re.compile(r'^1?$|^(11+)+$').match('1' * num) is None
def simple_is_prime(num):
"""Simple check if number is prime
More efficient than oneliner_is_prime as it breaks the loop
"""
for x in range(2, num):
if num % x == 0:
return False
return num > 1
def simple_gen_primes(limit=None):
"""Prime number generator based on simple gen"""
num = 2
while limit is None or num <= limit:
if simple_is_prime(num):
yield num
num += 1
if __name__ == "__main__":
less1000primes = list(gen_primes(limit=1000))
assert less1000primes == list(simple_gen_primes(limit=1000))
for num in range(1000):
assert (
(num in less1000primes)
== is_prime(num)
== oneliner_is_prime(num)
== regex_is_prime(num)
== simple_is_prime(num)
)
print("Primes less than 1000:")
print(less1000primes)
from timeit import timeit
print("
Timeit:")
print(
"gen_primes:",
timeit(
"list(gen_primes(limit=1000))",
setup="from __main__ import gen_primes",
number=1000,
),
)
print(
"simple_gen_primes:",
timeit(
"list(simple_gen_primes(limit=1000))",
setup="from __main__ import simple_gen_primes",
number=1000,
),
)
print(
"is_prime:",
timeit(
"[is_prime(num) for num in range(2, 1000)]",
setup="from __main__ import is_prime",
number=100,
),
)
print(
"oneliner_is_prime:",
timeit(
"[oneliner_is_prime(num) for num in range(2, 1000)]",
setup="from __main__ import oneliner_is_prime",
number=100,
),
)
print(
"regex_is_prime:",
timeit(
"[regex_is_prime(num) for num in range(2, 1000)]",
setup="from __main__ import regex_is_prime",
number=100,
),
)
print(
"simple_is_prime:",
timeit(
"[simple_is_prime(num) for num in range(2, 1000)]",
setup="from __main__ import simple_is_prime",
number=100,
),
)
运行此代码的结果显示出有趣的结果：
$ python prime_time.py
Primes less than 1000:
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
Timeit:
gen_primes: 0.6738066330144648
simple_gen_primes: 4.738092333020177
is_prime: 31.83770858097705
oneliner_is_prime: 3.3708438930043485
regex_is_prime: 8.692703998007346
simple_is_prime: 0.4686249239894096
所以我可以看到，对于不同的问题，我们在这里找到了正确的答案；对于素数生成器来说，gen_primes这看起来是正确的答案；但是对于素数检查，该simple_is_prime函数更适合。
这可行，但我总是愿意尝试更好的方法来实现is_prime此功能。
解决方案 11：
我认为最好采取功能性方法，
因此，我首先创建一个函数来确定该数字是否为质数，然后根据需要在循环或其他地方使用它。
def isprime(n):
for x in range(2,n):
if n%x == 0:
return False
return True
然后运行一个简单的列表推导或生成器表达式来获取素数列表，
[x for x in range(1,100) if isprime(x)]
解决方案 12：
这是我的实现。我确信有更有效的方法，但似乎有效。基本标志的使用。
def genPrime():
num = 1
prime = False
while True:
# Loop through all numbers up to num
for i in range(2, num+1):
# Check if num has remainder after the modulo of any previous numbers
if num % i == 0:
prime = False
# Num is only prime if no remainder and i is num
if i == num:
prime = True
break
if prime:
yield num
num += 1
else:
num += 1
prime = genPrime()
for _ in range(100):
print(next(prime))
解决方案 13：
python 3（生成素数）
from math import sqrt
i = 2
while True:
for x in range(2, int(sqrt(i) + 1)):
if i%x==0:
break
else:
print(i)
i += 1
解决方案 14：
您需要确保所有可能的除数都不能整除您正在检查的数字。在这种情况下，只要有一个可能的除数不能整除该数字，您就会打印您正在检查的数字。
另外，您不想使用 continue 语句，因为当您已经发现该数字不是质数时，continue 只会导致它检查下一个可能的除数。
解决方案 15：
这看起来像是家庭作业，所以我会给出提示而不是详细解释。如果我的假设错误，请纠正我。
当您看到偶数除数时，您就成功了。
但是，只要您看到一个不能整除的数字，您就会打印“count”。例如，2 不能整除 9。但这并不意味着 9 是质数。您可能需要继续，直到确定范围内没有匹配的数字。
（正如其他人所回复的那样，筛选是一种更有效的方法......只是想帮助您理解为什么这个特定的代码没有按照你想要的方式运行）
解决方案 16：
以下是我所拥有的：
def is_prime(num):
if num < 2: return False
elif num < 4: return True
elif not num % 2: return False
elif num < 9: return True
elif not num % 3: return False
else:
for n in range(5, int(math.sqrt(num) + 1), 6):
if not num % n:
return False
elif not num % (n + 2):
return False
return True
对于大数来说它的速度非常快，因为它仅检查数字的除数是否为素数。
现在如果您想生成一个素数列表，您可以执行以下操作：
# primes up to 'max'
def primes_max(max):
yield 2
for n in range(3, max, 2):
if is_prime(n):
yield n
# the first 'count' primes
def primes_count(count):
counter = 0
num = 3
yield 2
while counter < count:
if is_prime(num):
yield num
counter += 1
num += 2
为了提高效率，在这里使用生成器可能是理想的。
仅供参考，而不是说：
one = 1
while one == 1:
# do stuff
你可以简单地说：
while 1:
#do stuff
解决方案 17：
你可以用列表推导式以相当优雅的方式创建素数列表。摘自此处：
>>> noprimes = [j for i in range(2, 8) for j in range(i*2, 50, i)]
>>> primes = [x for x in range(2, 50) if x not in noprimes]
>>> print primes
>>> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
解决方案 18：
如果你想直接计算素数，那么如何做呢：
def oprime(n):
counter = 0
b = 1
if n == 1:
print 2
while counter < n-1:
b = b + 2
for a in range(2,b):
if b % a == 0:
break
else:
counter = counter + 1
if counter == n-1:
print b
解决方案 19：
与 user107745 类似，但使用“全部”而不是双重否定（可读性更强，但我认为性能相同）：
import math
[x for x in xrange(2,10000) if all(x%t for t in xrange(2,int(math.sqrt(x))+1))]
基本上，它会在 (2, 100) 范围内迭代 x，并仅挑选那些在范围 (2,x) 内所有 t 不具有 mod == 0 的 x
另一种方法可能就是在我们进行的过程中填充素数：
primes = set()
def isPrime(x):
if x in primes:
return x
for i in primes:
if not x % i:
return None
else:
primes.add(x)
return x
filter(isPrime, range(2,10000))
解决方案 20：
import time
maxnum=input("You want the prime number of 1 through....")
n=2
prime=[]
start=time.time()
while n<=maxnum:
d=2.0
pr=True
cntr=0
while d<n**.5:
if n%d==0:
pr=False
else:
break
d=d+1
if cntr==0:
prime.append(n)
#print n
n=n+1
print "Total time:",time.time()-start
解决方案 21：
如果你想找到某个范围内的所有素数，你可以这样做：
def is_prime(num):
"""Returns True if the number is prime
else False."""
if num == 0 or num == 1:
return False
for x in range(2, num):
if num % x == 0:
return False
else:
return True
num = 0
itr = 0
tot = ''
while itr <= 100:
itr = itr + 1
num = num + 1
if is_prime(num) == True:
print(num)
tot = tot + ' ' + str(num)
print(tot)
只需添加while its <=您的范围数字即可。
输出：
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 101
解决方案 22：
使用生成器：
def primes(num):
if 2 <= num:
yield 2
for i in range(3, num + 1, 2):
if all(i % x != 0 for x in range(3, int(math.sqrt(i) + 1))):
yield i
用法：
for i in primes(10):
print(i)
2、3、5、7
解决方案 23：
您可以使用一个函数在生成时检查它是否是素数，但这很慢，因此您可以使用线程模块，它可以让您更快地生成素数：
import threading
def is_prime(num):
if num < 2:
return False
return all(num % i != 0 for i in range(2, int(num ** 0.5) + 1))
def find_primes(start, end, result):
primes = [num for num in range(start, end) if is_prime(num)]
result.extend(primes)
def find_primes_parallel(start, end, num_threads):
result = []
threads = []
segment_size = (end - start) // num_threads
for i in range(num_threads):
seg_start = start + i * segment_size
seg_end = seg_start + segment_size
if i == num_threads - 1:
seg_end = end
thread = threading.Thread(target=find_primes, args=(seg_start, seg_end, result))
thread.start()
threads.append(thread)
for thread in threads:
thread.join()
return result
# Example usage
start_num = 1
end_num = 100000
num_threads = 4
primes = find_primes_parallel(start_num, end_num, num_threads)
print(primes)
解决方案 24：
continue 语句看起来是错误的。
您想从 2 开始，因为 2 是第一个质数。
您可以编写“while True:”来获得无限循环。
解决方案 25：
def genPrimes():
primes = [] # primes generated so far
last = 1 # last number tried
while True:
last += 1
for p in primes:
if last % p == 0:
break
else:
primes.append(last)
yield last
解决方案 26：
def check_prime(x):
if (x < 2):
return 0
elif (x == 2):
return 1
t = range(x)
for i in t[2:]:
if (x % i == 0):
return 0
return 1
解决方案 27：
对我来说，下面的解决方案看起来简单且易于遵循。
import math
def is_prime(num):
if num < 2:
return False
for i in range(2, int(math.sqrt(num) + 1)):
if num % i == 0:
return False
return True
解决方案 28：
这是我见过的最快的查找 n 以下素数的方法。1.2 秒内可达 100m。它使用纯 Python，无依赖项
def primes(lim):
if lim<7:
if lim<2: return []
if lim<3: return [2]
if lim<5: return [2, 3]
return [2, 3, 5]
n = (lim-1)//30
m = n+1
BA = bytearray
prime1 = BA([1])*m
prime7 = BA([1])*m
prime11 = BA([1])*m
prime13 = BA([1])*m
prime17 = BA([1])*m
prime19 = BA([1])*m
prime23 = BA([1])*m
prime29 = BA([1])*m
prime1[0] = 0
i = 0
try:
while 1:
if prime1[i]:
p = 30*i+1
l = i*(p+1)
prime1[l::p] = BA(1+(n-l)//p)
l += i*6
prime7[l::p] = BA(1+(n-l)//p)
l += i*4
prime11[l::p] = BA(1+(n-l)//p)
l += i*2
prime13[l::p] = BA(1+(n-l)//p)
l += i*4
prime17[l::p] = BA(1+(n-l)//p)
l += i*2
prime19[l::p] = BA(1+(n-l)//p)
l += i*4
prime23[l::p] = BA(1+(n-l)//p)
l += i*6
prime29[l::p] = BA(1+(n-l)//p)
if prime7[i]:
p = 30*i+7
l = i*(p+7)+1
prime19[l::p] = BA(1+(n-l)//p)
l += i*4+1
prime17[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime1[l::p] = BA(1+(n-l)//p)
l += i*4
prime29[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime13[l::p] = BA(1+(n-l)//p)
l += i*4+1
prime11[l::p] = BA(1+(n-l)//p)
l += i*6+1
prime23[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime7[l::p] = BA(1+(n-l)//p)
if prime11[i]:
p = 30*i+11
l = i*(p+11)+4
prime1[l::p] = BA(1+(n-l)//p)
l += i*2
prime23[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime7[l::p] = BA(1+(n-l)//p)
l += i*2
prime29[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime13[l::p] = BA(1+(n-l)//p)
l += i*6+2
prime19[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime11[l::p] = BA(1+(n-l)//p)
l += i*6+2
prime17[l::p] = BA(1+(n-l)//p)
if prime13[i]:
p = 30*i+13
l = i*(p+13)+5
prime19[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime11[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime7[l::p] = BA(1+(n-l)//p)
l += i*4+1
prime29[l::p] = BA(1+(n-l)//p)
l += i*6+3
prime17[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime13[l::p] = BA(1+(n-l)//p)
l += i*6+3
prime1[l::p] = BA(1+(n-l)//p)
l += i*4+1
prime23[l::p] = BA(1+(n-l)//p)
if prime17[i]:
p = 30*i+17
l = i*(p+17)+9
prime19[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime23[l::p] = BA(1+(n-l)//p)
l += i*4+3
prime1[l::p] = BA(1+(n-l)//p)
l += i*6+3
prime13[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime17[l::p] = BA(1+(n-l)//p)
l += i*6+3
prime29[l::p] = BA(1+(n-l)//p)
l += i*4+3
prime7[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime11[l::p] = BA(1+(n-l)//p)
if prime19[i]:
p = 30*i+19
l = i*(p+19)+12
prime1[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime17[l::p] = BA(1+(n-l)//p)
l += i*6+4
prime11[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime19[l::p] = BA(1+(n-l)//p)
l += i*6+4
prime13[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime29[l::p] = BA(1+(n-l)//p)
l += i*2+2
prime7[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime23[l::p] = BA(1+(n-l)//p)
if prime23[i]:
p = 30*i+23
l = i*(p+23)+17
prime19[l::p] = BA(1+(n-l)//p)
l += i*6+5
prime7[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime23[l::p] = BA(1+(n-l)//p)
l += i*6+5
prime11[l::p] = BA(1+(n-l)//p)
l += i*4+3
prime13[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime29[l::p] = BA(1+(n-l)//p)
l += i*4+4
prime1[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime17[l::p] = BA(1+(n-l)//p)
if prime29[i]:
p = 30*i+29
l = i*(p+29)+28
prime1[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime29[l::p] = BA(1+(n-l)//p)
l += i*6+6
prime23[l::p] = BA(1+(n-l)//p)
l += i*4+4
prime19[l::p] = BA(1+(n-l)//p)
l += i*2+2
prime17[l::p] = BA(1+(n-l)//p)
l += i*4+4
prime13[l::p] = BA(1+(n-l)//p)
l += i*2+2
prime11[l::p] = BA(1+(n-l)//p)
l += i*4+4
prime7[l::p] = BA(1+(n-l)//p)
i+=1
except:
pass
RES = [2, 3, 5]
A = RES.append
ti=0
try:
for i in range(n):
if prime1[i]:
A(ti+1)
if prime7[i]:
A(ti+7)
if prime11[i]:
A(ti+11)
if prime13[i]:
A(ti+13)
if prime17[i]:
A(ti+17)
if prime19[i]:
A(ti+19)
if prime23[i]:
A(ti+23)
if prime29[i]:
A(ti+29)
ti+=30
except:
pass
if prime1[n] and (30*n+1)<=lim:
A(30*n+1)
if prime7[n] and (30*n+7)<=lim:
A(30*n+7)
if prime11[n] and (30*n+11)<=lim:
A(30*n+11)
if prime13[n] and (30*n+13)<=lim:
A(30*n+13)
if prime17[n] and (30*n+17)<=lim:
A(30*n+17)
if prime19[n] and (30*n+19)<=lim:
A(30*n+19)
if prime23[n] and (30*n+23)<=lim:
A(30*n+23)
if prime29[n] and (30*n+29)<=lim:
A(30*n+29)
return RES
from time import time
n = time()
print (primes(100000000)[-1])
print (time() - n)
相关推荐
热门文章
项目管理软件有哪些？
热门标签
曾咪二维码
扫码咨询，免费领取项目管理大礼包！
云禅道AD
