Python Vérificateur de nombres premiers
J'ai essayé d'écrire un programme qui prendra un nombre entré, et de vérifier si c'est un nombre premier. Le code que j'ai créé jusqu'à présent fonctionne parfaitement si le nombre est en fait un nombre premier. Si le nombre n’est pas un nombre premier, il s’avère étrange. Je me demandais si quelqu'un pourrait me dire quel est le problème avec le code.
a=2
num=13
while num > a :
if num%a==0 & a!=num:
print('not prime')
a=a+1
else:
print('prime')
a=(num)+1
le résultat donné lorsque 24 est entré est: non premier pas premier pas premier premier
Comment pourrais-je corriger l'erreur avec le rapport premier sur chaque impaire et pas premier pour chaque paire
Vous devez cesser d'itérer lorsque vous savez qu'un nombre n'est pas premier. Ajoutez un break une fois que vous avez trouvé le premier pour sortir de la boucle while.
N'apportez que des modifications minimes à votre code pour le faire fonctionner:
a=2
num=13
while num > a :
if num%a==0 & a!=num:
print('not prime')
break
i += 1
else: # loop not exited via break
print('prime')
Votre algorithme est équivalent à:
for a in range(a, num):
if a % num == 0:
print('not prime')
break
else: # loop not exited via break
print('prime')
Si vous le lancez dans une fonction, vous pouvez vous passer de break et pour-else:
def is_prime(n):
for i in range(3, n):
if n % i == 0:
return False
return True
Même si vous allez avoir une force brute comme celle-ci, il vous suffit de parcourir la racine carrée de n. En outre, vous pouvez ignorer le test des nombres pairs après deux.
Avec ces suggestions:
import math
def is_prime(n):
if n % 2 == 0 and n > 2:
return False
for i in range(3, int(math.sqrt(n)) + 1, 2):
if n % i == 0:
return False
return True
Notez que ce code ne gère pas correctement 0, 1, et des nombres négatifs.
Nous simplifions les choses en utilisant all avec une expression génératrice pour remplacer la boucle for.
import math
def is_prime(n):
if n % 2 == 0 and n > 2:
return False
return all(n % i for i in range(3, int(math.sqrt(n)) + 1, 2))
def isprime(n):
'''check if integer n is a prime'''
# make sure n is a positive integer
n = abs(int(n))
# 0 and 1 are not primes
if n < 2:
return False
# 2 is the only even prime number
if n == 2:
return True
# all other even numbers are not primes
if not n & 1:
return False
# range starts with 3 and only needs to go up
# the square root of n for all odd numbers
for x in range(3, int(n**0.5) + 1, 2):
if n % x == 0:
return False
return True
Pris à partir de:
def is_prime(n):
return all(n%j for j in xrange(2, int(n**0.5)+1)) and n>1
Les deux principaux problèmes de votre code sont les suivants:
- Après avoir désigné un nombre non premier, vous continuez à vérifier le reste des diviseurs même si vous savez déjà qu’il n’est pas premier, ce qui peut entraîner l’impression "premier" après l’impression "non premier". Astuce: utilisez l'instruction `break '.
- Vous désignez un nombre premier avant d’avoir vérifié tous les diviseurs à vérifier, car vous imprimez "premier" intérieur la boucle. Donc, vous obtenez "prime" plusieurs fois, une fois pour chaque diviseur qui ne va pas uniformément dans le nombre testé. Astuce: utilisez une clause
elseavec la boucle pour imprimer "prime" uniquement si la boucle se termine sans se rompre.
Quelques inefficacités assez importantes:
- Vous devriez garder une trace des nombres que vous avez déjà trouvés et qui sont divisés par ceux-ci. Pourquoi diviser par 4 alors que vous avez déjà divisé par 2? Si un nombre est divisible par 4, il est également divisible par 2. Vous l'avez donc déjà attrapé et il n'est pas nécessaire de diviser par 4.
- Vous devez uniquement tester jusqu'à la racine carrée du nombre testé, car tout facteur supérieur à celui-ci devra être multiplié par un nombre inférieur à celui-ci, et il aurait déjà été testé au moment où vous passerez au plus grand.
Cet exemple est utilisé à réduire (), mais le ralentir:
def makepnl(pnl, n):
for p in pnl:
if n % p == 0:
return pnl
pnl.append(n)
return pnl
def isprime(n):
return True if n == reduce(makepnl, range(3, n + 1, 2), [2])[-1] else False
for i in range(20):
print i, isprime(i)
Il utilise Sieve Of Atkin , plus rapide que ci-dessus:
def atkin(limit):
if limit > 2:
yield 2
if limit > 3:
yield 3
import math
is_prime = [False] * (limit + 1)
for x in range(1,int(math.sqrt(limit))+1):
for y in range(1,int(math.sqrt(limit))+1):
n = 4*x**2 + y**2
if n<=limit and (n%12==1 or n%12==5):
# print "1st if"
is_prime[n] = not is_prime[n]
n = 3*x**2+y**2
if n<= limit and n%12==7:
# print "Second if"
is_prime[n] = not is_prime[n]
n = 3*x**2 - y**2
if x>y and n<=limit and n%12==11:
# print "third if"
is_prime[n] = not is_prime[n]
for n in range(5,int(math.sqrt(limit))):
if is_prime[n]:
for k in range(n**2,limit+1,n**2):
is_prime[k] = False
for n in range(5,limit):
if is_prime[n]: yield n
def isprime(n):
r = list(atkin(n+1))
if not r: return False
return True if n == r[-1] else False
for i in range(20):
print i, isprime(i)
Débutant ici, faites-le-moi savoir, mais je le ferais comme ceci:
def prime(n):
count = 0
for i in range(1, (n+1)):
if n % i == 0:
count += 1
if count > 2:
print "Not a prime"
else:
print "A prime"
Votre problème est que la boucle continue de s'exercer même si vous avez déjà "décidé". Vous devriez ajouter la ligne break après a=a+1
Une fois que vous avez déterminé qu'un nombre est composite (et non premier), votre travail est terminé. Vous pouvez sortir de la boucle avec break.
while num > a :
if num%a==0 & a!=num:
print('not prime')
break # not going to update a, going to quit instead
else:
print('prime')
a=(num)+1
Vous pouvez également essayer de vous familiariser avec certaines constructions en Python. Votre boucle peut être réduite à une ligne qui lit toujours bien à mon avis.
any(num % a == 0 for a in range(2, num))
Il s’agit d’une légère variation en ce sens qu’il enregistre les facteurs.
def prime(a):
list=[]
x=2
b=True
while x<a:
if a%x==0:
b=False
list.append(x)
x+=1
if b==False:
print "Not Prime"
print list
else:
print "Prime"
a=input("Enter number:")
def isprime():
total=0
factors=(1,a)# The only factors of a number
pfactors=range(1,a+1) #considering all possible factors
if a==1 or a==0:# One and Zero are not prime numbers
print "%d is NOT prime"%a
Elif a==2: # Two is the only even prime number
print "%d is prime"%a
Elif a%2==0:#Any even number is not prime except two
print "%d is NOT prime"%a
else:#a number is prime if its multiples are 1 and itself
#The sum of the number that return zero moduli should be equal to the "only" factors
for number in pfactors:
if (a%number)==0:
total+=number
if total!=sum(factors):
print "%d is NOT prime"%a
else:
print "%d is prime"%a
isprime()
Vérification du nombre premier.
def is_prime(x):
if x < 2:
return False
else:
if x == 2:
return True
else:
for i in range(2, x):
if x % i == 0:
return False
return True
x = int(raw_input("enter a prime number"))
print is_prime(x)
Cela ferait le travail:
number=int(raw_input("Enter a number to see if its prime:"))
if number <= 1:
print "number is not prime"
else:
a=2
check = True
while a != number:
if number%a == 0:
print "Number is not prime"
check = False
break
a+=1
if check == True:
print "Number is prime"
max=int(input("Find primes upto what numbers?"))
primeList=[]
for x in range(2,max+1):
isPrime=True
for y in range(2,int(x**0.5)+1) :
if x%y==0:
isPrime=False
break
if isPrime:
primeList.append(x)
print(primeList)