Python 计算素数

我现在正在做麻省理工学院的开放课程，而且已经是第二个作业了，我觉得它把我冷落了

它的细节是写一些可以计算第1000个素数的东西。我们只知道打印，==，=，1=，if，else，elif，而我认为，%，-，+，*，/，命令。我们还不知道如何导入库

我的想法是用一个奇数除以，3,4,5,6,7,8,9，如果%n=0，然后向NumberofPrimes变量添加一个数字，从11开始作为测试的基数，并在NumberofPrimes的基数处指定一个基值4，尽管我不知道这是否正确，因为我不知道如何显示第1000个素数

我接近了吗

最新版本如下：

##calculate the 1000th prime number
potprime = 3
numberofprime = 1
cycle = if potprime%3 = 0:
            break
        if potpimre%4 = 0:
            break
        if potprime%5 = 0:
            break
        if potprime%6 = 0:
            break
        if potprime%7 = 0:
            break
        if potprime%8 = 0:
            break
        if potprime%9 = 0:
            break
        numberofprime + 1
        potprime + 1

if potprime%2 == 0:
    potprime = potprime + 1
if potprime != 0:
    cycle

我到底错在哪里？一步一步地陪我走过。我真的很想学，虽然我觉得我只是被冷落在这里

---

在这一点上，我更愿意看到如何做一个合适的，而不是这样做。我已经工作了3个小时，但毫无进展。如果有人有一个解决办法，我会非常乐意去看看，并从中学习。

你的数学不及格。素数是一个有2个除数的数：1和它本身。您没有测试这些数字的素性。

首先，我非常确定，在Python中，如果您想要有一个if语句来测试A=B与否，您需要使用==运算符，而不是=

另一方面，你的算法会考虑数字143是素数，即使143＝11×13＜/p>

---

您需要跟踪已计算的所有素数-将它们添加到数组中。使用该数组来确定您正在测试的新数字是否为素数。

在我看来，您在确定kiddy pool太深后，正在跳入深水区。在大多数初级编程类中，质数项目将是赋值2或赋值3，就在基本语法被覆盖之后。我建议您在编写长程序之前尝试使用pythonshell学习语法，因为调试一行代码要比调试整个程序容易，而不是帮助您使用算法（有很多好的算法）。以下是您以实际运行的方式编写的内容：

count = 4
n = 10                        #I'm starting you at 10 because your method 
                              #says that 2, 3, 5, and 7 are not prime
d = [2, 3, 4, 5, 6, 7, 8, 9]  #a list containing the ints you were dividing by

def cycle(n):                 #This is how you define a function
    for i in d:               #i will be each value in the list d
        if not n%i:           #this is equal to if n%i == 0
            return 0          #not prime (well, according to this anyway)
    return 1                  #prime

while count < 1000:
    count += cycle(n)         #adds the return from cycle to count
    n += 1

print n - 1

count=4
n=10#我从10岁开始教你，因为你的方法
#表示2，3，5和7不是素数
d=[2,3,4,5,6,7,8,9]#包含要除以的整数的列表
定义周期（n）：#这是定义函数的方式
对于d中的i:#i将是列表d中的每个值
如果不是n%i:#这等于n%i==0
返回0#不是素数（好吧，无论如何根据这个）
返回1#素数
当计数小于1000时：
计数+=周期（n）#将周期的返回值与计数相加
n+=1
打印n-1

答案仍然不正确，因为这不是测试素数的方法。但是知道一点语法至少会让你得到错误的答案，这比大量的回溯要好

（另外，我意识到列表、循环和函数不在您所说的您知道的内容列表中。）

下面的代码很粗糙，但由于1000确实是一个小索引，它在几分之一秒内解决了您的问题（并且它只使用您到目前为止应该知道的原语）：

primesFound=0
数字=1
当primesFound<1000时：
数字=数字+1#从2开始
#素性检验
除数=2
numberIsPrime=True
除数*除数来回答你接下来的问题，“我如何跟踪所有素数？”

一种方法是列一个清单

primeList = [] # initializes a list

然后，每次测试一个数字是否为素数时，将该数字添加到
primeList

您可以使用“append”函数来实现这一点

primeList.append( potprime )  # adds each prime number to that list

然后你会看到列表中充满了数字，所以在前三个素数之后，它看起来是这样的：

>>> primeList
[11, 13, 17]

看来我迟到了

很简单，如果一个数不能被任何素数整除，那么这个数本身就是一个素数。您可以使用此事实来最小化分区数

为此，您需要维护一个素数列表。对于每个数字，只尝试用列表中已经存在的素数除法。为了进一步优化它，您可以舍弃所有素数，而不是要测试的数的平方根。您需要为此导入sqrt（）函数

例如，如果您在1001上进行测试，请尝试使用3、5、7、11、13、17、19、23、29和31进行测试。这应该足够了。也不要试图找出一个偶数是否是素数。基本上，如果你测试一个奇数n，那么在测试之后，下一个数字是：（n+2）

已经测试了下面的代码。第1000个素数是7919。不是一个大数字

代码可能类似于：

from math import sqrt

primeList = [2]
num = 3
isPrime = 1

while len(primeList) < 1000:
    sqrtNum = sqrt(num)

    # test by dividing with only prime numbers
    for primeNumber in primeList:

        # skip testing with prime numbers greater than square root of number
        if num % primeNumber == 0:
            isPrime = 0
            break
        if primeNumber > sqrtNum:
            break

    if isPrime == 1:
        primeList.append(num)
    else:
        isPrime = 1

    #skip even numbers
    num += 2

# print 1000th prime number
print primeList[999]

从数学导入sqrt
primeList=[2]
num=3
isPrime=1
而len（primeList）<1000：
sqrtNum=sqrt（num）
#仅用素数除法进行测试
对于primeList中的primeNumber：
#跳过质数大于数字平方根的测试
如果num%primeNumber==0：
isPrime=0
打破
如果primeNumber>sqrtNum：
打破
如果isPrime==1：
primeList.append（num）
其他：
isPrime=1
#跳过偶数
num+=2
#打印第1000个素数
打印列表[999]
这个答案的代码可以压缩为：

prime_count = 1
start_number = 2
number_to_check = 2
while prime_count <= 1000:
    result = number_to_check % start_number

    if result > 0:
        start_number +=1

    elif result == 0:
        if start_number == number_to_check:
            print (number_to_check)
            number_to_check +=1
            prime_count +=1
            start_number =2
        else:
            number_to_check +=1
            start_number = 2

prime\u count=1
起始编号=2
编号\u至\u检查=2
当素数为0时：
起始编号+=1
elif结果==0：
如果开始编号==要检查的编号：
打印（数字到支票）
编号\u至\u检查+=1
prime_count = 1
start_number = 2
number_to_check = 2
while prime_count <= 1000:
    result = number_to_check % start_number

    if result > 0:
        start_number +=1

    elif result == 0:
        if start_number == number_to_check:
            print (number_to_check)
            number_to_check +=1
            prime_count +=1
            start_number =2
        else:
            number_to_check +=1
            start_number = 2

#Initialise some variables
candidate = 1 
prime_counter = 1 

while prime_counter < 1000: 
    test = 2 
    candidate = candidate + 2

    # While there is a remainder the number is potentially prime.
    while candidate%test > 0:
        test = test + 1

    # No remainder and test = candidate means candidate is prime.
    if candidate == test: 
        prime_counter = prime_counter + 1

print "The 1000th prime is: " + str(candidate)

from math import *

#Initialise some variables
candidate = 1 
prime_counter = 1 
sum_logs = log(2)

while prime_counter < 10000: 
    test = 2 
    candidate = candidate + 2
    # While there is a remainder the number is potentially prime.
    while candidate%test > 0:
        test = test + 1
    # No remainder and test = candidate means candidate is prime.
    if candidate == test: 
        prime_counter = prime_counter + 1
    # If the number is prime add its log to the sum of logs.
        sum_logs = sum_logs + log(candidate)
    if prime_counter%1000 == 0:
        # For every 1000th prime print the result.
        print sum_logs," ",candidate," ",sum_logs/candidate
print "The 10000th prime is: " + str(candidate)

from math import *

MAX_IDX=1000
MAX_IDX-=1

num_iter=0

l_pirme_list=[3]
candidate=l_pirme_list[0]
prime_counter=1

while prime_counter < MAX_IDX: 
    candidate+=2
    #Cut the binary number in half. This is quite faster than sqrt()
    bin_candidate=format(candidate, "2b")
    max_prime_search=int(bin_candidate[:len(bin_candidate)/2+1],2)+1
    # max_prime_search=sqrt(candidate)+1

    candidate_is_prime=1
    for prime_item in l_pirme_list:
        num_iter+=1

        if candidate % prime_item==0:
            candidate_is_prime=0
            break

        elif prime_item > max_prime_search:
            candidate_is_prime=1
            break


    if candidate_is_prime:
        prime_counter+=1
        l_pirme_list.append(candidate)

l_pirme_list.insert(0,2)
print "number iterations=", num_iter
print l_pirme_list[MAX_IDX]