Как создать 1000-е простое число в python?

пара проблем очевидны. Во-первых, поскольку вы начинаете с 11, вы уже пропустили первые 5 простых чисел, поэтому счет должен начинаться с 5.

Что еще более важно, ваш основной алгоритм обнаружения просто не будет работать. Вы должны отслеживать все простые числа, меньшие, чем я, для такого упрощенного "сита Эратостанов", как простое обнаружение. Например, ваш алгоритм будет думать, что 11 * 13 = 143 является простым, но, очевидно, это не так.

PGsimple1 здесь является правильной реализацией того, что вы пытаетесь сделать здесь, но другие алгоритмы намного быстрее.

вы уверены, что правильно проверять первичные? Типичным решением является наличие отдельной функции "isPrime", которая, как вы знаете, работает.

def isPrime(num):
    i = 0
    for factor in xrange(2, num):
        if num%factor == 0:
            return False
    return True

(есть способы сделать вышеуказанную функцию более эффективной, например, только проверка шансов и только чисел ниже квадратного корня и т. д.)

затем, чтобы найти n-е простое число, посчитайте все простые числа, пока не найдете его:

def nthPrime(n):
    found = 0
    guess = 1
    while found < n:
        guess = guess + 1
        if isPrime(guess):
            found = found + 1
    return guess

ваша логика не очень правильная. в то время как :

if i%2 != 0:
    if (i%3 == 0 or i%4 == 0 or i%5 == 0 or i%6 == 0 or i%7 == 0 or i%9 == 0):

это не может судить, является ли число простым или нет .

Я думаю, вы должны проверить, все ли числа ниже sqrt(i) делят i .

вот функция is_prime, с которой я где-то столкнулся, вероятно, на SO.

def is_prime(n):
  return all((n%j > 0) for j in xrange(2, n))

primes = []

n = 1
while len(primes) <= 1000: 
    if is_prime(n):
        primes.append(n)
    n += 1

или, если вы хотите, чтобы все это было в цикле, просто используйте возврат функции is_prime.

primes = []    
n = 1
while len(primes) <= 1000: 
    if all((n%j > 0) for j in xrange(2, n)):
        primes.append(n)
    n += 1

Это, вероятно, быстрее: попробуйте разделить num от 2 до sqrt(num)+1 вместо диапазона (2,num).

from math import sqrt

i = 2 
count = 1

while True:
    i += 1
    prime = True
    div = 2
    limit = sqrt(i) + 1
    while div < limit:
        if not (i % div):
            prime = False
            break
        else:
            div += 1
    if prime:
        count += 1
    if count == 1000:
        print "The 1000th prime number is %s" %i
        break

попробуйте это:

def isprime(num):
    count = num//2 + 1
    while count > 1:
        if num %count == 0:
            return False
        count -= 1
    else:
        return True

num = 0
count = 0
while count < 1000:
    num += 1
    if isprime(num):
        count += 1
    if count == 1000:
        prime = num

проблемы с вашим кодом:

1. нет необходимости проверять, если i

2. Вы делаете это

   if i%2 != 0:
       if (i%3 == 0 or i%4 == 0 or i%5 == 0 or i%6 == 0 or i%7 == 0 or i%9 == 0):
   

   здесь вы не проверяете, делится ли число на простое число больше 7. Таким образом, ваш результат: скорее всего, делящееся на 11

3. из-за 2. ваш алгоритм говорит 17 * 13 * 11 является простым (чего нет)

Как насчет этого:

#!/usr/bin/python

from math import sqrt

def is_prime(n):
    if n == 2:
        return True
    if (n < 2) or (n % 2 == 0):
        return False
    return all(n % i for i in xrange(3, int(sqrt(n)) + 1, 2))

def which_prime(N):
    n = 2
    p = 1
    while True:
        x = is_prime(n)
        if x:
            if p == N:
                return n
            else:
                p += 1
        n += 1
print which_prime(1000)

n=2                         ## the first prime no.
prime=1                     ## we already know 2 is the first prime no.
while prime!=1000:          ## to get 1000th prime no.
    n+=1                    ## increase number by 1
    pon=1                   ## sets prime_or_not(pon) counter to 1
    for i in range(2,n):    ## i varies from 2 to n-1
        if (n%i)==0:        ## if n is divisible by i, n is not prime
            pon+=1          ## increases prime_or_not counter if  n is not prime
    if pon==1:              ## checks if n is prime or not at the end of for loop
        prime+=1            ## if n is prime, increase prime counter by 1
print n                     ## prints the thousandth prime no.

вот еще одно представление:

ans = 0;
primeCounter = 0;
while primeCounter < 1000:
    ans += 1;    
    if ans % 2 != 0: 
        # we have an odd number
        # start testing for prime
        divisor = 2;
        isPrime = True;
        while divisor < ans:
            if ans % divisor == 0: 
                isPrime = False;
                break;
            divisor += 1;
        if isPrime:             
            print str(ans) + ' is the ' + str(primeCounter) + ' prime';
            primeCounter += 1;
print 'the 1000th prime is ' + str(ans);

вот метод, использующий только циклы if & while. Это выведет только 1000-е простое число. Он пропускает 2. Я сделал это как набор задач 1 для курса OCW 6.00 MIT и поэтому включает только команды, преподаваемые до второй лекции.

prime_counter = 0  
number = 3  

while(prime_counter < 999):
    divisor = 2
    divcounter = 0
    while(divisor < number):
        if(number%divisor == 0):
            divcounter = 1  
        divisor += 1
    if(divcounter == 0):
        prime_counter+=1
    if(prime_counter == 999):
        print '1000th prime number: ', number
    number+=2

Я только что написал это. Он спросит вас, сколько простых чисел пользователь хочет видеть, в этом случае это будет 1000. Не стесняйтесь использовать его :).

# p is the sequence number of prime series
# n is the sequence of natural numbers to be tested if prime or not
# i is the sequence of natural numbers which will be used to devide n for testing
# L is the sequence limit of prime series user wants to see
p=2;n=3
L=int(input('Enter the how many prime numbers you want to see: '))
print ('# 1  prime is 2')
while(p<=L):
    i=2
    while i<n:
        if n%i==0:break
        i+=1
    else:print('#',p,' prime is',n); p+=1
    n+=1 #Line X

#when it breaks it doesn't execute the else and goes to the line 'X'