Найти первые N простых чисел в python

Ответ 1

с помощью regexp:)

#!/usr/bin/python

import re, sys


def isPrime(n):
    # see http://www.noulakaz.net/weblog/2007/03/18/a-regular-expression-to-check-for-prime-numbers/
    return re.match(r'^1?$|^(11+?)\1+$', '1' * n) == None


N = int(sys.argv[1]) # number of primes wanted (from command-line)
M = 100              # upper-bound of search space
l = list()           # result list

while len(l) < N:
    l += filter(isPrime, range(M - 100, M)) # append prime element of [M - 100, M] to l
    M += 100                                # increment upper-bound

print l[:N] # print result list limited to N elements

Ответ 2

Реализация супер быстрого сита Дэвид Эпштейн - занимает 0.146 с для первых 1000 простых чисел на моем ПК:

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 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

primes = gen_primes()


x = set()
y = 0
a = gen_primes()
while y < 10000:
  x |= set([a.next()])
  y+=1

print "x contains {:,d} primes".format(len(x))
print "largest is {:,d}".format(sorted(x)[-1])

Ответ 3

Для справки существует довольно значительная разница в скорости между различными заявленными решениями. Вот пример кода сравнения. Решение, на которое указывает Леннарт, называется "историческим", тот, который предложен Муравьями, называется "наивным", а тот, который называется RC, называется "регулярным выражением".

from sys import argv
from time import time

def prime(i, primes):
    for prime in primes:
        if not (i == prime or i % prime):
            return False
    primes.add(i)
    return i

def historic(n):
    primes = set([2])
    i, p = 2, 0
    while True:
        if prime(i, primes):
            p += 1
            if p == n:
                return primes
        i += 1

def naive(n):
    from itertools import count, islice
    primes = (n for n in count(2) if all(n % d for d in range(2, n)))
    return islice(primes, 0, n)

def isPrime(n):
    import re
    # see http://tinyurl.com/3dbhjv
    return re.match(r'^1?$|^(11+?)\1+$', '1' * n) == None

def regexp(n):
    import sys
    N = int(sys.argv[1]) # number of primes wanted (from command-line)
    M = 100              # upper-bound of search space
    l = list()           # result list

    while len(l) < N:
        l += filter(isPrime, range(M - 100, M)) # append prime element of [M - 100, M] to l
        M += 100                                # increment upper-bound

    return l[:N] # print result list limited to N elements

def dotime(func, n):
    print func.__name__
    start = time()
    print sorted(list(func(n)))
    print 'Time in seconds: ' + str(time() - start)

if __name__ == "__main__":
    for func in naive, historic, regexp:
        dotime(func, int(argv[1]))

Выход этого на моем компьютере для n = 100:

naive
[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]
Time in seconds: 0.0219371318817
historic
[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]
Time in seconds: 0.00515413284302
regexp
[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]
Time in seconds: 0.0733318328857

Как вы можете видеть, существует довольно большое несоответствие. Здесь это снова для 1000 (первичные выходы удалены):

naive
Time in seconds: 1.49018788338
historic
Time in seconds: 0.148319005966
regexp
Time in seconds: 29.2350409031

Ответ 4

Строка k = k-1 не делает то, что вы думаете. Это не имеет никакого эффекта. Изменение k не влияет на цикл. На каждой итерации k присваивается следующий элемент диапазона, поэтому любые изменения, сделанные вами в k внутри цикла, будут перезаписаны.

Ответ 5

Что вы хотите, это примерно так:

x = int(input("Enter the number:"))
count = 0
num = 2
while count < x:
     if isnumprime(x):
        print x
        count = count + 1
     num = num + 1

Я оставлю это для вас, чтобы реализовать "isnumprime()".;) Подсказка: вам нужно всего лишь проверить деление со всеми ранее найденными примерами.

Ответ 6

Вот что я в итоге придумал для печати первых n простых чисел:

numprimes = raw_input('How many primes to print?  ')
count = 0
potentialprime = 2

def primetest(potentialprime):
    divisor = 2
    while divisor <= potentialprime:
        if potentialprime == 2:
            return True
        elif potentialprime % divisor == 0:
            return False
            break
        while potentialprime % divisor != 0:
            if potentialprime - divisor > 1:
                divisor += 1
            else:
                return True

while count < int(numprimes):
    if primetest(potentialprime) == True:
        print 'Prime #' + str(count + 1), 'is', potentialprime
        count += 1
        potentialprime += 1
    else:
        potentialprime += 1

Ответ 7

Что вам нужно - это Prime Sieve (быстрый алгоритм поиска простых чисел), очень простой - это сито Eratosthenes (проверьте википедию), и вот реализация в PHP http://www.scriptol.com/programming/sieve.php

Ответ 8

До тех пор, пока мы не будем иметь N простых чисел, возьмем натуральные числа один за другим, проверьте, не разделит ли их один из так называемых простых чисел.

Если это не так, "yay", у нас есть новое простое...

что он.

>>> def generate_n_primes(N):
...     primes  = []
...     chkthis = 2
...     while len(primes) < N:
...         ptest    = [chkthis for i in primes if chkthis%i == 0]
...         primes  += [] if ptest else [chkthis]
...         chkthis += 1
...     return primes
...
>>> print generate_n_primes(15)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

Ответ 9

Использование выражений генератора для создания последовательности всех простых чисел и срезания 100-го из этого.

from itertools import count, islice
primes = (n for n in count(2) if all(n % d for d in range(2, n)))
print("100th prime is %d" % next(islice(primes, 99, 100)))

Ответ 10

def isPrime(y):
  i=2
  while i < y:
    if y%i == 0 :
      return 0
      exit()
    i=i+1
  return 1

x= raw_input('Enter the position 1st,2nd,..nth prime number you are looking for?: ')
z=int(x)
# for l in range(2,z)
count = 1
n = 2
while count <= z:
  if isPrime(n) == 1:
    if count == z:
      print n
    count +=1
  n=n+1

Ответ 11

Вы можете взять количество входов простых чисел. В соответствии с вашим методом я сделал здесь предопределенное количество 10:

i = 2
if i == 2:
    print(str(i) + "is a prime no")
    i = i+1
c=1

while c<10:
    for j in range(2, i):
        if i%j==0:
            break

    if i == j+1:
        print(str(i) + "is aa prime no")
        c=c+1

    i=i+1

Ответ 12

Этот код очень смущен, и я не могу точно определить, что вы думаете, когда вы его написали или что вы пытались выполнить. Первое, что я хотел бы предложить, пытаясь понять, как кодировать, - это начать с того, что ваши имена переменных чрезвычайно наглядны. Это поможет вам получить идеи о том, что вы делаете прямо в своей голове, а также поможет любому, кто пытается помочь вам показать вам, как правильно ваши идеи.

Говоря это, вот примерная программа, которая выполняет что-то близкое к цели:

primewanted = int(input("This program will give you the nth prime.\nPlease enter n:"))
if primewanted <= 0:
    print "n must be >= 1"
else:
    lastprime = 2 # 2 is the very first prime number
    primesfound = 1  # Since 2 is the very first prime, we've found 1 prime
    possibleprime = lastprime + 1 # Start search for new primes right after
    while primesfound < primewanted:
        # Start at 2.  Things divisible by 1 might still be prime
        testdivisor = 2
        # Something is still possibly prime if it divided with a remainder.
        still_possibly_prime = ((possibleprime % testdivisor) != 0)
        # (testdivisor + 1) because we never want to divide a number by itself.
        while still_possibly_prime and ((testdivisor + 1) < possibleprime):
            testdivisor = testdivisor + 1
            still_possibly_prime = ((possibleprime % testdivisor) != 0)
        # If after all that looping the prime is still possibly prime,
        # then it is prime.
        if still_possibly_prime:
            lastprime = possibleprime
            primesfound = primesfound + 1
        # Go on ahead to see if the next number is prime
        possibleprime = possibleprime + 1
    print "This nth prime is:", lastprime

Этот бит кода:

        testdivisor = 2
        # Something is still possibly prime if it divided with a remainder.
        still_possibly_prime = ((possibleprime % testdivisor) != 0)
        # (testdivisor + 1) because we never want to divide a number by itself.
        while still_possibly_prime and ((testdivisor + 1) < possibleprime):
            testdivisor = testdivisor + 1
            still_possibly_prime = ((possibleprime % testdivisor) != 0)

может быть заменен несколько медленным, но, возможно, более понятным:

        # Assume the number is prime until we prove otherwise
        still_possibly_prime = True
        # Start at 2.  Things divisible by 1 might still be prime
        for testdivisor in xrange(2, possibleprime, 1):
            # Something is still possibly prime if it divided with a
            # remainder.  And if it is ever found to be not prime, it not
            # prime, so never check again.
            if still_possibly_prime:
                still_possibly_prime = ((possibleprime % testdivisor) != 0)

Ответ 13

n=int(input("Enter the number:: "))

for i in range(2,n):
    p=i
    k=0
    for j in range(2,p-1):
        if(p%j==0):
            k=k+1
    if(k==0):
        print(p)

Ответ 14

Это может помочь:

import sys
from time import time
def prime(N):
    M=100
    l=[]
    while len(l) < N:
        for i in range(M-100,M):    
            num = filter(lambda y :i % y == 0,(y for y in range(2 ,(i/2)))) 
            if not num and i not in [0,1,4]:
                l.append(i)
        M +=100
    return l[:N]


def dotime(func, n):
    print func.__name__
    start = time()
    print sorted(list(func(n))),len(list(func(n)))
    print 'Time in seconds: ' + str(time() - start)


if __name__ == "__main__":
    dotime(prime, int(sys.argv[1]))

Ответ 15

Здесь простая рекурсивная версия:

import datetime
import math

def is_prime(n, div=2):
    if div> int(math.sqrt(n)): return True
    if n% div == 0:
        return False
    else:
        div+=1
        return is_prime(n,div)


now = datetime.datetime.now()

until = raw_input("How many prime numbers my lord desires??? ")
until = int(until)

primelist=[]
i=1;
while len(primelist)<until:
    if is_prime(i):
        primelist.insert(0,i)
        i+=1
    else: i+=1



print "++++++++++++++++++++"
print primelist
finish = datetime.datetime.now()
print "It took your computer", finish - now , "secs to calculate it"

Здесь версия, использующая рекурсивную функцию с памятью!:

import datetime
import math

def is_prime(n, div=2):
    global primelist
    if div> int(math.sqrt(n)): return True
    if div < primelist[0]:
        div = primelist[0]
        for x in primelist:
            if x ==0 or x==1: continue
            if n % x == 0:
                return False
    if n% div == 0:
        return False
    else:
        div+=1
        return is_prime(n,div)


now = datetime.datetime.now()
print 'time and date:',now

until = raw_input("How many prime numbers my lord desires??? ")
until = int(until)

primelist=[]
i=1;
while len(primelist)<until:
    if is_prime(i):
        primelist.insert(0,i)
        i+=1
    else: i+=1



print "Here you go!"
print primelist

finish = datetime.datetime.now()
print "It took your computer", finish - now , " to calculate it"

Надеюсь, это поможет:)

Ответ 16

Попробуйте использовать цикл while, чтобы проверить счет, это легко. Найдите фрагмент кода ниже:

i=1
count = 0;
x = int(input("Enter the number:\n"))
while (count < x):
c=0
for j in range (1, (i+1), 1):
    a = i%j
    if (a==0):
        c = c+1

if (c==2):
      print (i)
      count = count+1
i=i+1

Ответ 17

В то время как игра с простыми числами в Python V3 я заметил, что наименьшее число, с помощью которого составное (неглавное) число делится, всегда является простым числом, которое меньше квадратного корня из тестируемого числа.

Ниже приведена моя реализация этого поиска для вычисления первых N простых чисел.

первые 1000 простых чисел в 0.028S | первые 10 000 простых чисел в 0,6 | первые 100 000 простых чисел в 14.3S

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

import time
import math

def first_n_Primes(n):
    number_under_test = 4
    primes = [2,3]
    while len(primes) < n:
        check = False
        for prime in primes:
            if prime > math.sqrt(number_under_test) : break
            if number_under_test % prime == 0:
                check = True
                break
        if not check:
            for counter in range(primes[len(primes)-1],number_under_test-1,2):
                if number_under_test % counter == 0:
                    check = True
                    break
        if not check:
            primes.append(number_under_test)
        number_under_test+=1
    return primes

start_time = time.time()
data = first_n_Primes(1000)
end_time = time.time()

i = 1
while i < len(data)+1:
    print('{0: <9}'.format(str(data[i-1])), end="")
    if i%10 == 0: print("")
    i+=1

print("\nFirst %d primes took %s seconds ---" % (len(data),end_time - start_time))

Ответ 18

Это моя версия

import timeit
import math

__author__ = 'rain'


primes = [2]

def is_prime(n):
    for prime in primes:
        if n % prime == 0:
            return False
    return True


def find_nth_prime(n):
    current_index = 0
    while(len(primes) < n):
        if current_index == 0:
            start_value = 3
            end_value = 2 * 2
        else:
            start_value = primes[current_index - 1] * primes[current_index - 1] + 1
            end_value = primes[current_index] * primes[current_index]
        for i in range(start_value, end_value):
            if is_prime(i):
                primes.append(i)
        current_index += 1
    return primes[n-1]


def solve():
    return find_nth_prime(10001)

print solve()

print timeit.timeit(solve, number=10)

Я использую сито для сканирования простых чисел, это довольно быстро

Требуется всего 3,8e-06 секунд, чтобы получить 10001-е число (10 раз).

Ответ 19

Попробуйте следующее:

primeList = []
for num in range(2,10000):
    if all(num%i!=0 for i in range(2,num)):
        primeList.append(num)
x = int(raw_input("Enter n: "))
for i in range(x):
    print primeList[i]

Ответ 20

max = input("enter the maximum limit to check prime number");
if max>1 :
    for i in range (2,max):
        prime=0;
        for j in range (2,i):
            if(i%j==0):
                prime=1;
                break
        if(prime==0 and i!=0):
            print(i,"is prime number");
else:
    print("prime no start from 2");

Ответ 21

prime=2
counter = 0
x = int(input("Enter the number:\n"))
while (counter < x):
    if all(prime%j!=0 for j in range(2, prime)):
        print(prime, "is a prime number")
        counter+=1


    prime+=1

Ответ 22

count = -1
n = int(raw_input("how many primes you want starting from 2 "))
primes=[[]]*n
for p in range(2, n**2):
    for i in range(2, p):
        if p % i == 0:
            break
    else:
        count +=1
        primes[count]= p
        if count == n-1:
            break

print (primes)
print 'Done'

Ответ 23

Anwer здесь просто, т.е. Запускает цикл "n" раз.

n=int(input())
count=0
i=2
while count<n:
    flag=0
    j=2
    while j<=int(i**0.5):
        if i%j==0:
            flag+=1
        j+=1
    if flag==0:
        print(i,end=" ")
        count+=1
    i+=1

Ответ 24

Вам не нужно объявлять так много переменных, см. Приведенный ниже код прост и легок для понимания.

for num in range(1,50):     
   for i in range(2,num):    
      if num%i == 0:                  
         break 
   else:                 
      print(num,'is a prime')

Вывод первых 50 простых чисел

Ответ 25

#!/usr/bin/python3
import sys

primary_numbers = [1, 2]


def is_prime(i):
    for pn in enumerate(primary_numbers[2:]):
        if i % pn[1] == 0:
            return False

    return True

def main(position):
    i = 3
    while len(primary_numbers) < int(position):
        print(i)
        res = is_prime(i)
        if res:
            primary_numbers.append(i)
        i += 2


if __name__ == '__main__':
    position = sys.argv[1]
    main(position)
    print(primary_numbers)

Ответ 26

def isprime(n):
    if n <= 1:
        return False
    for x in range(2, n):
        if n % x == 0:
            return False
    else:
        return True

def list_prime(z):
    y = 0
    def to_infinity():
        index=0
        while 1:
            yield index
            index += 1
    for n in to_infinity():
        if y < z:
            if isprime(n):
                y = y + 1
                print(n, end='\n', flush=True)
        else:break
    print(f'\n {z} prime numbers are as above.')

# put your range below
list_prime(10)

Ответ 27

Я не знаком с Python, поэтому я пишу часть счетчика C (слишком ленив, чтобы писать псевдокод..: P) Найти первые n простых чисел. // печатает все простые числа, не мешая сделать массив и возвращать его и т.д.

void find_first_n_primes(int n){
   int count = 0;
   for(int i=2;count<=n;i++){
     factFlag == 0; //flag for factor count... 
     for(int k=2;k<sqrt(n)+1;k++){
       if(i%k == 0) // factor found..
        factFlag++;
     }
      if(factFlag==0)// no factors found hence prime..
        {
         Print(i);   // prime displayed..
         count++;
        }
   }
}

Ответ 28

Это может помочь:

def in_prime(n):
    p=True
    i=2
    if i**2<=n:
        if n%i==0:
            p=False
            break
    if (p):
        return n

Ответ 29

Привет! Я очень плохо знаком с кодированием, только начал 4 дня назад. Я написал код, чтобы вернуть первые 1000 простых чисел, включая 1. Посмотрите

n=1
c=0
while n>0:
   for i in range(2,n):
      if n%i == 0:
         break
   else:
      print(n,'is a prime')
      c=c+1
   n=n+1
   if c==1000:
      break

Ответ 30

def Isprime(z):
    '''returns True if the number is prime OTW returns false'''
    if z<1:
        return False
    elif z==1:
        return False

    elif z==2:
        return True 

    else:
        for i in range(2,z):
            if z%i==0:
                return False
            else:
                return True

Так я это сделал. Конечно, есть так много способов сделать это.