小练习：20160418 计算两百万以下所有质数的和

无下限HENTAI

1. import math
   
2. def prime_sum(n):
   
3.     list_prime = [2]
   
4.     def next_prime():
   
5.         length = len(list_prime)
   
6.         temp = list_prime[length-1]
   
7.         while  True:
   
8.             temp += 1
   
9.             flag = 1
   
10.             for i in range(length):
    
11.                 if list_prime[i] <= math.sqrt(temp):
    
12.                     if temp%list_prime[i] != 0:
    
13.                         continue
    
14.                     else:
    
15.                         flag = 0
    
16.                         break
    
17.                 else:
    
18.                     break
    
19.             if flag == 1:
    
20.                 list_prime.append(temp)
    
21.                 break
    
22.     while list_prime[-1] < n:
    
23.         next_prime()
    
24.     list_prime.pop()
    
25.     result = sum(list_prime)
    
26.     return result
    
27. n = int(input('请输入一个正整数：'))
    
28. print('%d以下的所有质数和为%d' % (n,prime_sum(n)))

复制代码

输出答案：
请输入一个正整数：2000000
2000000以下的所有质数和为142913828922

cold2wind

采用过滤的思想，首先过滤掉大于等于4的偶数的倍数，然后依次过滤奇数的倍数。
经测试当n = 1000000时，运行时间为2.14秒，欢迎优化

1. # -*- encoding = 'utf-8' -*-
   
2. import time
   
3. # n以下的质数的和
   
4. def primeNumberSum(n):
   
5.     if n < 2:
   
6.         return 0
   
7. 
   
8.     if n == 3:
   
9.         return 2;
   
10. 
    
11.     prime = [i for i in range(n)]
    
12.     prime[1] = 0
    
13. 
    
14.     # 过滤掉>=4的偶数的倍数(2,4,6,8...等的倍数)
    
15.     for i in range(4,n,2):
    
16.         prime[i] = 0
    
17. 
    
18.     # 过滤掉奇数的倍数
    
19.     for i in range(3,n // 2,2):
    
20.         # 从2 * i开始过滤
    
21.         for j in range(i + i,n,i):
    
22.             # 若prime[j]已经为0，则不再赋值
    
23.             if prime[j]:
    
24.                 prime[j] = 0
    
25. 
    
26.     return sum(prime)
    
27. 
    
28. if __name__ == '__main__':
    
29.     begin = time.time()
    
30.     print(primeNumberSum(1000000))
    
31.     end = time.time()
    
32.     print(str(end - begin) + 's')

复制代码

zooo

粗暴的实现了数域筛选...

1. #如果为和数则置零，如果为质数则将它的倍数置零
   
2. import time
   
3. def isprime(num):
   
4.     num **= 0.5
   
5.     for i in range(2, int(num+1)):
   
6.         if num%i==0:
   
7.             return False
   
8.     return True
   
9. 
   
10. begTime = time.time()
    
11. iNum = [x for x in range(2,2000001)]
    
12. for n in iNum:
    
13.     #忽略0
    
14.     if n:
    
15.         #不是质数则置零
    
16.         if not isprime:
    
17.             iNum[n-2] = 0
    
18.             continue
    
19.         #是质数则将它的倍数置零
    
20.         if isprime:
    
21.             #setzero()
    
22.             ratio = 2
    
23.             while True:
    
24.                 nNext = n * ratio
    
25.                 ratio += 1
    
26.                 if nNext > 2000000:
    
27.                     break
    
28.                 iNum[nNext-2] = 0
    
29.                
    
30. print(sum(iNum),time.time()-begTime)

复制代码

詹姆西

1. from math import sqrt
   
2. NUM=2000000
   
3. add=0
   
4. 
   
5. def is_prime(num):
   
6.        for i in range(2,int(sqrt(num)+1)):
   
7.               if num % i == 0:
   
8.                      return(0)
   
9.        return(1)
   
10. 
    
11. for i in range(2,NUM+1):
    
12.        if is_prime(i):
    
13.               #print(i)
    
14.               add+=i
    
15. print(add)

复制代码

gklee2014

1. # using python2
   
2. import math
   
3. 
   
4. 
   
5. def isprime(x):
   
6.     for i in range(2, int(math.sqrt(x)) + 1):
   
7.         if x % i == 0:
   
8.             return False
   
9.         else:
   
10.             continue
    
11.     return True
    
12. 
    
13. temp = [i for i in range(3, 2000000, 2) if isprime(i)]
    
14. result = 2 + sum(temp)
    
15. print result

复制代码

bacon6581

远程控制的树莓派 linux系统
python3下完成，代码不好复制过来，只好截图了
答案为：454396537