I recently started messing around with python and I wrote a program to print out the 1000th prime number but the output only shows a blinking cursor , the code is shown below:
number = 3
count= 1
while count <= 1000:
prime = True
for x in range(2, number):
if number % x == 0:
prime= False
if prime == True:
count = count + 1
if count <= 1000:
number = number + 1
print number
Any help and concise explanation would be appreciated
edit: i just realized the problem. #tichodroma solved the problem but did so by editing the OP post. so when i got to it it was already solved, how ever, he solved it by putting the print into the loop, hence the many numbers waterfall. but it should be outside the loop so as to only show the final result. also - after looking at the OP code before edit, it was written in such a way that it was taking a long time to run, and the "blinking line" was the system working in the background
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 squareroot 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
counter = 0
number = 0
while True:
if isprime(number):
counter+=1
if counter == 10000:
break
number+=1
print number
Related
I'm reading a book about python programming for begginers.
One of it's tasks is to write a prime number calcutator that calculates 'n' prime numbers.
So far I've studied strings, logic gates, while and conditions.
The idea is to make it using only those operators.
I need help because I'm stuck with this code.
Here's what I've done:
odd = 3
number = 2
limit = int(input('How many primes do you need: '))
remnant = number % odd
even_remnant = number % 2
counter = 0
while counter <= limit:
if number == 2:
print('2')
number += 2
elif (number % 2) != 0:
remnant = number % odd
while odd < number:
print('while2')
remnant = number % odd
if (number % odd) != 0 and odd == (number - 1):
print(f'{number}.')
odd = 3
number += 1
counter += 1
break
elif (number % odd) == 0:
break
odd += 2
elif (number % 2) == 0:
number += 1
odd = 3
What do you think?
Thanks everyone.
Put your debugging pants on, we're going in.
First, the code doesn't run as it's written. The variables counter and impar are undefined. First step is to remove syntax errors like that. Looks like we want to start counter at 0 and the line that uses impar isn't necessary so we can delete it.
odd = 3
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
if number == 2:
print('2')
number += 2
elif (number % 2) != 0:
while odd < number:
print('while2')
remnant = number % odd
if (number % odd) != 0 and odd == (number - 1):
print(f'{number}.')
odd = 3
number += 1
break
elif (number % odd) == 0:
break
odd += 2
elif (number % 2) == 0:
number += 1
odd = 3
Now the code runs without error, but all it does is print
2
while2
And then fails to terminate.
So we know we enter the while odd < number loop only once and we don't print anything during that loop. If we also print the value of odd and number while we are in there we see odd = 3 and number = 5. Neither of the if conditions are met and the odd += 2 line is hit. Now odd = 5 and the while loop exits without printing 5 even though 5 is prime. If we want to hit our print statement by meeting the condition odd == (number - 1) we better go in steps of 1 when incrementing odd. Let's change to odd += 1 and re-run the code.
Now when I say I need 2 primes it prints
2
5
7
And then prints while2 forever. At least it prints prime numbers! But it skipped 3 and printed too many, and I had to use Ctrl-C to quit the program. Too many primes were printed because the outer loop while counter <= limit: condition was never reached. Inside the loop, we never increase the value of counter. Whenever we print a prime, we need to increase counter.
Also, to make sure we print 3, take a look at the first if condition in the loop.
if number == 2:
print('2')
number += 2 # Oops, we skipped over 3
Let's update this:
if number == 2:
print('2')
print('3')
counter += 2 # Let's count both of these!
number += 2
Also adding counter += 1 after the other print, re-running the code we get
How many primes do you need: 2
2
3
5.
How many primes do you need: 3
2
3
5.
7.
Oops, we are getting one more than we need. This is because when counter == limit we run the while loop one more time. Let's change our while loop condition to while counter < limit:. That change gets us just the right number of primes.
How many primes do you need: 4
2
3
5.
7.
But if we ask for 5
How many primes do you need: 5
2
3
5.
7.
And the program never exits. If we check the values of odd and number, we see that the loops is running with odd=3 and number=9 over and over again.
Reason through the code when odd=3 and number=9. We break out of the while odd < number while loop when we hit this code
elif (number % odd) == 0
break
But we never increase the value of number, so it is still equal to 9 the next time through the loop. Let's update this to
elif (number % odd) == 0
number += 1
break
Now when we re-run the code we get
How many primes do you need: 5
2
3
5.
7.
11.
Huzzah! And it works when asking for more primes as well. Here is the code as it is currently:
odd = 3
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
if number == 2:
print('2')
print('3')
counter += 2
number += 2
elif (number % 2) != 0:
while odd < number:
if (number % odd) != 0 and odd == (number - 1):
print(f'{number}.')
odd = 3
number += 1
break
elif (number % odd) == 0:
number += 1
break
odd += 1
elif (number % 2) == 0:
number += 1
odd = 3
Now that we have working code, let's improve it! One of our bugs was that we forgot to increase number by 1 in one case. Notice that no matter how we exit the outer while loop while counter <= limit: we want to increment number. So, instead of doing it in many places, let's move all of those to the end of the while block.
We also set odd=3 whenever exiting the while block. What we want to ensure is that odd=3 at the start of the while loop, so let's move that there. Now there is no more code in the elif (number % 2) == 0: block, so we can remove that line.
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
odd = 3
if number == 2:
print('2')
print('3')
counter += 2
elif (number % 2) != 0:
while odd < number:
if (number % odd) != 0 and odd == (number - 1):
print(f'{number}.')
counter += 1
break
elif (number % odd) == 0:
break
odd += 1
number += 1
I think the code is more clear if the while loop ends when the condition is met, rather than on break statements. We want the while loop to end if we find the number is divisible by something, or we run out of numbers to check.
`while number % odd != 0 and odd < number:`
And the only thing we need to do in the while loop is increment odd. Then after the loop, we can check the value of odd to see which condition was met.
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
odd = 3
if number == 2:
print('2')
print('3')
counter += 2
elif (number % 2) != 0:
while number % odd != 0 and odd < number:
odd += 1
if odd == number: # No divisor was found!
print(f'{number}.')
counter += 1
number += 1
Notice that we are "hard coding" the divisibility by 2 (number % 2) != 0 and then using the variable odd to check divisibility by everything else. If we start odd at 2 instead of 3, we don't have to do the hard coding.
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
odd = 2
if number == 2:
print('2')
print('3')
counter += 2
while number % odd != 0 and odd < number:
odd += 1
if odd == number: # No divisor was found!
print(f'{number}.')
counter += 1
number += 1
When we make this change, we also notice that we find the primes 2 and 3 twice, so we can remove the hard coded version of those:
number = 2
limit = int(input('How many primes do you need: '))
counter = 0
while counter < limit:
odd = 2
while number % odd != 0 and odd < number:
odd += 1
if odd == number: # No divisor was found!
print(f'{number}.')
counter += 1
number += 1
When I try to run this code it tells me that Counter is not set, so right before entering the loop set Counter to 0.
Another problem is that you start by finding 2 in the first case of your loop, this is nice. Here after the loop runs again, now with number set to 4. Because of your += 2 instruction.
It then runs the last elif case. where (number % 2) == 0. here it set number = 5, and odd = 3. But it doesn't print 3. I think you mean to do this.
Now it runs the loop again, and enter the second elif case (number % 2) != 0.
The first line in the elif clause the variable impar is not defined so it will fail.
I can't understand your program but it's good
def is_prime(n):
st = "prime" # being prime status
for i in range(2,n):
if n % i == 0: # if number is prime
st = "not prime"
break;
return st
n = int(input("enter n: "))
pc = 0 # prime conter
c = 1 # counter
while n != pc:
if is_prime(c) == "prime":
print (c)
pc += 1
c += 1
To calculate 'n' number for prime numbers you needn't use so many statements, if you make use of the the arithmetic and logical or bit-wise operators, which you will be learning in the future chapters of the python book you're referring.
I shall help you by editing the code for you.
number = int(input("Enter range: "))
print("Prime numbers:", end=' ')
for n in range(2, number):
for i in range(2, n):
if n % i == 0:
break
else:
print(n, end=' ')
Question:
Given the prime number n, output the number of prime numbers
My code:
def kthPrime(self, n):
if n>10 and n%10 not in [1,3,7,9]:
return 0
if n == 2:
return 1
queue = []
num = 2
while num <= n:
if n%num == 0 and num != n:
return 0
if num>10 and num%10 not in [1,3,7,9]:
num += 1
continue
for i in range(2,num/2+1):
if num%i == 0:
num += 1
break
else:
queue.append(num)
num += 1
seq = queue.index(n) + 1
return seq
Error:
Your code ran too much time than we expected. Check your time complexity. Time limit exceeded usually caused by infinite loop if your time complexity is the best.
My Question: how to improve it
as user #Prune said , please read the guide first.
I'm not going to tell you how to improve your function , but I'm just gonna give you a faster way to see whether a number is prime or not and hopefully you will understand how to use the function that I'm gonna give you to improve your own function.
The source code :
class numChecker:
def is_prime(self,n):
if n == 2:
return True
if n % 2 == 0 or n < 2:
return False
self.square_root = int(n ** (1/2))
for divisor in range(3, self.square_root + 1, +2):
if n % divisor == 0:
return False
return True
I know that python is "slow as dirt", but i would like to make a fast and efficient program that finds primes. This is what i have:
num = 5 #Start at five, 2 and 3 are printed manually and 4 is a multiple of 2
print("2")
print("3")
def isPrime(n):
#It uses the fact that a prime (except 2 and 3) is of form 6k - 1 or 6k + 1 and looks only at divisors of this form.
i = 5
w = 2
while (i * i <= n): #You only need to check up too the square root of n
if (n % i == 0): #If n is divisable by i, it is not a prime
return False
i += w
w = 6 - w
return True #If it isn´t ruled out by now, it is a prime
while True:
if ((num % 2 != 0) and (num % 3 != 0)): #save time, only run the function of numbers that are not multiples of 2 or 3
if (isPrime(num) == True):
print(num) #print the now proved prime out to the screen
num += 2 #You only need to check odd numbers
Now comes my questions:
-Does this print out ALL prime numbers?
-Does this print out any numbers that aren't primes?
-Are there more efficient ways(there probably are)?
-How far will this go(limitations of python), and are there any ways to increase upper limit?
Using python 2.7.12
Does this print out ALL prime numbers?
There are infinitely many primes, as demonstrated by Euclid around 300 BC. So the answer to that question is most likely no.
Does this print out any numbers that aren't primes?
By the looks of it, it doesn't. However, to be sure; why not write a unit test?
Are there more efficient ways(there probably are)? -How far will this go(limitations of python), and are there any ways to increase upper limit?
See Fastest way to list all primes below N or Finding the 10001st prime - how to optimize?
Checking for num % 2 != 0 even though you increment by 2 each time seems pointless.
I have found that this algorithm is faster:
primes=[]
n=3
print("2")
while True:
is_prime=True
for prime in primes:
if n % prime ==0:
is_prime=False
break
if prime*prime>n:
break
if is_prime:
primes.append(n)
print (n)
n+=2
This is very simple. The function below returns True if num is a prime, otherwise False. Here, if we find a factor, other than 1 and itself, then we early stop the iterations because the number is not a prime.
def is_this_a_prime(num):
if num < 2 : return False # primes must be greater than 1
for i in range(2,num): # for all integers between 2 and num
if(num % i == 0): # search if num has a factor other than 1 and itself
return False # if it does break, no need to search further, return False
return True # if it doesn't we reached that point, so num is a prime, return True
I tried to optimize the code a bit, and this is what I've done.Instead of running the loop for n or n/2 times, I've done it using a conditional statements.(I think it's a bit faster)
def prime(num1, num2):
import math
def_ = [2,3,5,7,11]
result = []
for i in range(num1, num2):
if i%2!=0 and i%3!=0 and i%5!=0 and i%7!=0 and i%11!=0:
x = str(math.sqrt(i)).split('.')
if int(x[1][0]) > 0:
result.append(i)
else:
continue
return def_+result if num1 < 12 else result
I'm trying to write a program that picks out the primes in a range from 3 to 9. Here's my code:
primes_list = []
number = 3
while number > 2 and number < 10:
for n in range(2, number):
if number % n == 0:
break
number += 1
else:
primes_list.append(number)
print primes_list
This seems to be an infinite loop but that's just a guess because the output never shows up. If it is an infinite loop, why?
Also I was wondering if there's some sort of list comprehension that can pick out only prime numbers? Maybe list comprehensions is the more efficient way to go? only I haven't figure out how to just filter the primes.
Any help or comment is deeply appreciated.
while number > 2 and number < 10:
for n in range(2, number):
if number % n == 0:
break
else:
primes_list.append(number)
number += 1
>>> primes_list
[3, 5, 7]
>>>
This is probably what you had in mind.
Note that number += 1 inside the first loop was misplaced
for n in range(2, number):
if number % n == 0:
break
number += 1
Because of the break, you never get to
number += 1
when that condition is met. It will just keep appending number to the list forever.
Try something along the lines of:
primes_list = []
lower = 3
upper = 10
for number in range(lower, upper):
if(isPrime(number)):
primes_list.append(number)
print primes_list
#note this is not an efficient implementation
def isPrime(number):
for n in range(2, number):
if number % n == 0:
return false
return true
For this question, I need to find the largest prime number within a larger number. For the purpose of the example, let's say the larger number is "123456789", then some of the numbers I would have to check are 12, 456, 234567, etc.
I wrote some Python code to figure this out, but it is running very slow for the number I am trying to check. The actual number I am working with is about 10000 digits, so there are a lot of numbers I need to look at. Here is my code:
num = "123456789"
def isPrime(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 squareroot of n
# for all odd numbers
for x in range(3, long(n**0.5)+1, 2):
if n % x == 0:
return False
return True
def largestPrime():
largest = 2
for i in range(0,len(num)):
for j in range(i+1,len(num)):
if isPrime(long(num[i:j])):
if long(num[i:j]) > largest:
largest =long(num[i:j])
print largest
def main():
largestPrime()
main()
I'm pretty sure this code gives the correct answer, but as I said, it's really slow. Can anyone help me figure out how to speed this up?
Thanks for any help!
I'd probably use the strategy of starting with the total number of digits and seeing if that's prime. Then keep decreasing the digits by one while shifting over to the left to see if that's prime. Let me explain with an example:
123456789
First check the 9-digit number: 123456789
Then check the 8-digit numbers: 23456789, 12345678
Then Check the 7-digit numbers: 3456789, 2345678, 1234567
etc.
One problem I see is that for some large numbers you are going to be testing the same number many times. For example for '123456712345671234567', your code will test '1234567' 3 times. I suggest you make a set that contains no duplicates, then run your prime test on each number. I also think that sorting the numbers is a good idea because we can stop after the first prime is found.
Next if you are dealing with large numbers (e.g. 10000 digits), I suggest using a statistical primality test. Below I made a Miller-Rabin primality test using pseudocode from wikipedia.
I have pretty much rewritten your code :P
import random
num = '3456647867843652345683947582397589235623896514759283590867843652345683947582397589235623896514759283590784235876867843652345683947582397589235623896514759283590784235876867843652345683947582397589235623896514759283590784235876867843652345683947582397589235623896514759283590784235876867843652345683947582397589235623896514759283590784235876867843652345683947582397589235623896514759283590784235876867843652345683947582397589235623896514759283590784235876784235876324650'
def probablyPrime(num, k):
"""Using Miller-Rabin primality test"""
if num == 2 or num == 3:
return True
if num < 2:
return False
if not num & 1:
return False
# find s and d such that n−1 = (2**s)*d with d odd
d = (num-1) >> 1
s = 1
while not (d & 1):
d = d >> 1
s += 1
# run k times
for _ in range(k):
a = random.randint(2, num-2)
x = pow(a, d, num) # more efficient than x = a**d % num
if not (x == 1 or x == num-1):
for _ in range(s-1):
x = (x**2) % num
if x == 1:
return False
if x == num-1:
break
if not x == num-1:
return False
return True
def largestPrime(num):
num_list = set([])
for i in range(0,len(num)+1):
for j in range(i+1,len(num)+1):
inum = int(num[i:j])
# Don't append numbers that have already appeared
if inum not in num_list:
num_list.add(inum)
# Convert to list and sort
num_list = list(num_list)
num_list.sort(reverse=True)
for num in num_list:
print('Checking ' + str(num))
if probablyPrime(num,100):
print('\n' + str(num) + ' is probably the largest prime!')
return
largestPrime(num)
Another way to improve speed might be python's multiprocessing package.
Code:
def isprime(n):
if n == 2:
return str(n)+" is the biggest prime"
if n % 2 == 0:
return isprime(n-1) #not prime, check again for next biggest number
max = n**0.5+1
i = 3
while i <= max:
if n % i == 0:
return isprime(n-1) #not prime, check again for next biggest number
i+=2
return str(n)+" is the biggest prime"
print "Testing 7:",isprime(7)
print "Testing 23:",isprime(23)
print "Testing 2245:",isprime(2245)
print "Testing 222457:",isprime(222457)
print "Testing 727245628:",isprime(727245628)
Output:
>>>
Testing 7: 7 is the biggest prime
Testing 23: 23 is the biggest prime
Testing 2245: 2243 is the biggest prime
Testing 222457: 222437 is the biggest prime
Testing 727245628: 727245613 is the biggest prime