Pour trouver les N premiers nombres premiers en python
Je suis nouveau dans le monde de la programmation. Je viens d'écrire ce code en python pour générer N nombres premiers. L'utilisateur doit entrer la valeur de N, qui correspond au nombre total de nombres premiers à imprimer. J'ai écrit ce code mais il ne jette pas la sortie souhaitée. Au lieu de cela, il affiche les nombres premiers jusqu'au Nième nombre. Par exemple: L'utilisateur entre la valeur de N = 7. Sortie souhaitée: 2, 3, 5, 7, 11, 13, 19 Rendement réel: 2, 3, 5, 7
Veuillez aviser.
i=1
x = int(input("Enter the number:"))
for k in range (1, (x+1), 1):
c=0
for j in range (1, (i+1), 1):
a = i%j
if (a==0):
c = c+1
if (c==2):
print (i)
else:
k = k-1
i=i+1
en utilisant une expression rationnelle :)
#!/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
La mise en place du tamisage rapide par David Eppstein - prend 0,146s pour les 1000 premiers nombres premiers sur mon PC:
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
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])
Pour référence, il existe une différence de vitesse assez importante entre les différentes solutions indiquées. Voici un code de comparaison. La solution indiquée par Lennart est appelée "historique", celle proposée par Ants est appelée "naïve" et celle de RC s'appelle "regexp".
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 __== "__main__":
for func in naive, historic, regexp:
dotime(func, int(argv[1]))
La sortie de this sur ma machine pour n = 100 est:
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
Comme vous pouvez le constater, il y a un assez gros écart. La voici à nouveau pour 1000 (sorties principales supprimées):
naive
Time in seconds: 1.49018788338
historic
Time in seconds: 0.148319005966
regexp
Time in seconds: 29.2350409031
La ligne k = k-1 ne fait pas ce que vous pensez. Cela n'a aucun effet. Changer k n'affecte pas la boucle. À chaque itération, k est affecté à l'élément suivant de la plage. Ainsi, toutes les modifications apportées à k dans la boucle seront écrasées.
Voici ce que j’ai finalement trouvé pour imprimer les n premiers nombres premiers:
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
Ce que vous voulez, c'est quelque chose comme ça:
x = int(input("Enter the number:"))
count = 0
num = 2
while count < x:
if isnumprime(x):
print x
count = count + 1
num = num + 1
Je vous laisse le soin d'implémenter "isnumprime ()". ;) Astuce: Il suffit de tester la division avec tous les numéros de téléphone précédemment trouvés.
Utiliser des expressions de générateur pour créer une séquence de tous les nombres premiers et trancher le centième de celui-ci.
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)))
Jusqu'à ce que nous ayons N nombres premiers, prenons les nombres naturels un par un et vérifions si l'un des nombres premiers collectés jusqu'à présent le divise.
Si aucun ne le fait, "yay", nous avons un nouveau premier ...
c'est tout.
>>> 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]
Ce dont vous avez besoin est un Prime Sieve (un type d’algorithme rapide pour la recherche de nombres premiers), très simple: Sieve of Eratosthenes (consultez wikipedia) et voici une implémentation dans PHP http: // www .scriptol.com/programming/sieve.php
Vous pouvez prendre le nombre d'entrées de nombres premiers. Selon votre méthode, j'ai pris ici un compte prédéfini de 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
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
En jouant avec les nombres premiers dans Python V3, j'ai remarqué que le plus petit nombre par lequel un nombre composite (non premier) est divisible est toujours un nombre premier inférieur à la racine carrée du nombre à tester.
Ci-dessous, ma mise en œuvre de cette conclusion pour calculer les N premiers nombres premiers.
1000 premiers nombres premiers dans 0.028S | 10 000 premiers nombres premiers en 0.6S | 100 000 premiers nombres premiers en 14.3S
L'extrait ci-dessous indique également combien de temps la génération a pris et affiche les nombres premiers dans un format de table Nice.
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))
Cela pourrait aider:
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 __== "__main__":
dotime(prime, int(sys.argv[1]))
Essayez d’utiliser la boucle while pour vérifier le compte, c’est facile. Trouvez l'extrait de code ci-dessous:
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
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");
Ce code est très confus et je ne peux pas comprendre exactement ce que vous pensiez quand vous l'avez écrit ou ce que vous tentiez d'accomplir. La première chose que je suggère lorsque vous essayez de comprendre comment coder est de commencer par rendre vos noms de variables extrêmement descriptifs. Cela vous aidera à avoir les idées de ce que vous faites dans la tête et à aider tous ceux qui essaient de vous aider à vous montrer comment concrétiser vos idées.
Cela étant dit, voici un exemple de programme qui permet de réaliser un objectif proche de l'objectif:
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
Ce morceau de code:
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)
pourrait éventuellement être remplacé par le plus lent, mais peut-être plus compréhensible:
# 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's not
# prime, so never check again.
if still_possibly_prime:
still_possibly_prime = ((possibleprime % testdivisor) != 0)
Voici une version simple récursive:
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"
Voici une version utilisant une fonction récursive avec mémoire !:
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"
J'espère que ça aide :)
Essaye ça:
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]
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)
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
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'
La réponse est simple, c’est-à-dire exécuter la boucle n fois.
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
Ceci est ma version
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)
J'utilise un tamis pour analyser les nombres premiers, c'est assez rapide
Cela prend seulement 3.8e-06 secondes pour obtenir le 10001e nombre premier (10 fois).