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=' ')
Related
number = 50
while number >= 0:
if number % 5 == 0:
print(number)
number = number - 1
elif number % 5 == 1:
continue
number = number = number - 1
the answer it's giving me is 50 then the loop stops executing
Here is the program I am trying to make:
While Loops Practice #2
Create a While Loop that subtracts one by one the numbers from 50 to 0 (both numbers included) with the following additional conditions:
If the number is divisible by 5, show that number on the screen (remember that here you can use the modulus operation dividing by 5 and checking the remainder!)
If the number is not divisible by 5, continue executing the loop without showing the value on the screen (don't forget to continue subtracting so that the program doesn't run infinitely).
Here is your code, improved:
number = 50
while number >= 0:
if number % 5 == 0:
print(number)
number = number - 1
I'm confused about that too, but here are my thoughts: you only subtracted when number % 5 == 1, but it can also be 2, 3, 4 or 5.
num = 50
while num != 0:
if num % 5 == 0:
print(num)
num -= 1
would work for this as it will only print the number if it is divisible by 5, and always subtract.
Make sure you always subtract 1 from number before continuing the loop. As the prompt reminds you, this is especially important when you use the continue statement, since that brings you straight back to the top of the loop -- if you haven't subtracted before then, the loop will repeat infinitely!
One way to make sure that something always happens even if execution is interrupted (not just a continue but maybe a return, a break, a raise, etc) is try/finally:
number = 50
while number >= 0:
try:
if number % 5 == 0:
print(number)
elif number % 5 == 1:
continue
finally:
number -= 1
prints:
50
45
40
35
30
25
20
15
10
5
0
In this case, though, there's no need to immediately continue the loop, since there's nothing in the loop that you explicitly need to skip in the number % 5 == 1 case (note that this isn't the same as "not divisible by 5" -- what you're testing for here is "has a reminder of 1 after dividing by 5", i.e. 1, 6, 11, and so on, which isn't part of the problem statement).
You can therefore just do:
number = 50
while number >= 0:
if number % 5 == 0:
print(number)
number -= 1
The main structure is corret, but in the last line you wrote two times the code "number =" and "else" is useless in this case, because you need to substract 1 in every loop.
here's the code solved:
number = 50
while number != 0:
if (number%5) == 0:
print(number)
number = number - 1
My code is:
currentNum = 0
divisible = True
prime = 0
counter = 1
counter2 = 1
counter3 = 0
counter4 = 0
while not counter == 10:
while not counter2 == counter:
currentNum = counter / counter2
while not counter3 == counter:
if currentNum == counter3:
counter4 = counter4 + 1
if counter4 == 1:
divisible = True
counter4 = 0
else:
divisible = False
prime = prime + 1
counter4 = 0
counter3 = 0
counter2 = 1
counter = counter + 1
print(prime)
but for some reason it only shows 0.5 whenever I try to use it.
Well first 0 and 1 are not prime numbers so we must take care of that. Also 2 is prime so we must also take care of that. Now that the outlier prime numbers are out we can focus on the normal ones.
A prime number can only be divided by 1 and itself. So we must make a list to and make sure our input can't be divided by any number in that list. Also even numbers are out of the playing field since they can be divided by 2.
First I make a function to check the input against every number up to the number to see if it can be divided by other numbers. Then I check if the number is even (num%2 is a good way to check if something is even) or if the number can be divided by any other number.
See how I put the even check first to save time if the number is even we don't have to check all the numbers in the list we can just return false without iterating through the entire list.
def is_prime(num):
if num < 0 or num in [0,1]:
return False
elif num == 2:
return True
def prime_range_check():
for number in range(2,num):
if num%number == 0:
return False
if num % 2 == 0 or prime_range_check() == False:
return False
return True
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
My program should print the sum from even numbers from 2 to 10, but when I pass even_while() in the shell I don't see any result. Which is the problem?
def even_while():
number = 2
s = 0
while number < 10:
if number % 2 == 0:
old_number = number
number = number + 1
s = s + old_number
print(s)
Thanks!
"Infinite loop". number starts as 2. That's even, so add 1 to it. That leaves number as 3. Now the while loop goes around "forever". number % 2 == 0 is never true (number is 3!), and number never changes again.
You don't increment number unless number % 2 == 0, so the while loop doesn't make any progress.
Additionally, you might enjoy the range builtin:
def even_while():
s = 0
for number in range(2, 10):
if number % 2 == 0:
old_number = number
s = s + old_number
print(s)
def even_while():
number = 0
s = 0
while number < 11:
number = number + 1
if number % 2 == 0:
old_number = number
s = s + old_number
print(s)
I think this is ok.
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