Could someone please tell me what I'm doing wrong with this code? It is just printing 'count' anyway. I just want a very simple prime generator (nothing fancy).
import math
def main():
count = 3
one = 1
while one == 1:
for x in range(2, int(math.sqrt(count) + 1)):
if count % x == 0:
continue
if count % x != 0:
print count
count += 1
There are some problems:
Why do you print out count when it didn't divide by x? It doesn't mean it's prime, it means only that this particular x doesn't divide it
continue moves to the next loop iteration - but you really want to stop it using break
Here's your code with a few fixes, it prints out only primes:
import math
def main():
count = 3
while True:
isprime = True
for x in range(2, int(math.sqrt(count) + 1)):
if count % x == 0:
isprime = False
break
if isprime:
print count
count += 1
For much more efficient prime generation, see the Sieve of Eratosthenes, as others have suggested. Here's a nice, optimized implementation with many comments:
# Sieve of Eratosthenes
# Code by David Eppstein, UC Irvine, 28 Feb 2002
# http://code.activestate.com/recipes/117119/
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
Note that it returns a generator.
re is powerful:
import re
def isprime(n):
return re.compile(r'^1?$|^(11+)\1+$').match('1' * n) is None
print [x for x in range(100) if isprime(x)]
###########Output#############
[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]
def is_prime(num):
"""Returns True if the number is prime
else False."""
if num == 0 or num == 1:
return False
for x in range(2, num):
if num % x == 0:
return False
else:
return True
>> filter(is_prime, range(1, 20))
[2, 3, 5, 7, 11, 13, 17, 19]
We will get all the prime numbers upto 20 in a list.
I could have used Sieve of Eratosthenes but you said
you want something very simple. ;)
print [x for x in range(2,100) if not [t for t in range(2,x) if not x%t]]
def primes(n): # simple sieve of multiples
odds = range(3, n+1, 2)
sieve = set(sum([list(range(q*q, n+1, q+q)) for q in odds], []))
return [2] + [p for p in odds if p not in sieve]
>>> primes(50)
[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
To test if a number is prime:
>>> 541 in primes(541)
True
>>> 543 in primes(543)
False
SymPy is a Python library for symbolic mathematics. It provides several functions to generate prime numbers.
isprime(n) # Test if n is a prime number (True) or not (False).
primerange(a, b) # Generate a list of all prime numbers in the range [a, b).
randprime(a, b) # Return a random prime number in the range [a, b).
primepi(n) # Return the number of prime numbers less than or equal to n.
prime(nth) # Return the nth prime, with the primes indexed as prime(1) = 2. The nth prime is approximately n*log(n) and can never be larger than 2**n.
prevprime(n, ith=1) # Return the largest prime smaller than n
nextprime(n) # Return the ith prime greater than n
sieve.primerange(a, b) # Generate all prime numbers in the range [a, b), implemented as a dynamically growing sieve of Eratosthenes.
Here are some examples.
>>> import sympy
>>>
>>> sympy.isprime(5)
True
>>> list(sympy.primerange(0, 100))
[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]
>>> sympy.randprime(0, 100)
83
>>> sympy.randprime(0, 100)
41
>>> sympy.prime(3)
5
>>> sympy.prevprime(50)
47
>>> sympy.nextprime(50)
53
>>> list(sympy.sieve.primerange(0, 100))
[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]
Here's a simple (Python 2.6.2) solution... which is in-line with the OP's original request (now six-months old); and should be a perfectly acceptable solution in any "programming 101" course... Hence this post.
import math
def isPrime(n):
for i in range(2, int(math.sqrt(n)+1)):
if n % i == 0:
return False;
return n>1;
print 2
for n in range(3, 50):
if isPrime(n):
print n
This simple "brute force" method is "fast enough" for numbers upto about about 16,000 on modern PC's (took about 8 seconds on my 2GHz box).
Obviously, this could be done much more efficiently, by not recalculating the primeness of every even number, or every multiple of 3, 5, 7, etc for every single number... See the Sieve of Eratosthenes (see eliben's implementation above), or even the Sieve of Atkin if you're feeling particularly brave and/or crazy.
Caveat Emptor: I'm a python noob. Please don't take anything I say as gospel.
Here is a numpy version of Sieve of Eratosthenes having both okay complexity (lower than sorting an array of length n) and vectorization.
import numpy as np
def generate_primes(n):
is_prime = np.ones(n+1,dtype=bool)
is_prime[0:2] = False
for i in range(int(n**0.5)+1):
if is_prime[i]:
is_prime[i*2::i]=False
return np.where(is_prime)[0]
Timings:
import time
for i in range(2,10):
timer =time.time()
generate_primes(10**i)
print('n = 10^',i,' time =', round(time.time()-timer,6))
>> n = 10^ 2 time = 5.6e-05
>> n = 10^ 3 time = 6.4e-05
>> n = 10^ 4 time = 0.000114
>> n = 10^ 5 time = 0.000593
>> n = 10^ 6 time = 0.00467
>> n = 10^ 7 time = 0.177758
>> n = 10^ 8 time = 1.701312
>> n = 10^ 9 time = 19.322478
python 3 (generate prime number)
from math import sqrt
i = 2
while True:
for x in range(2, int(sqrt(i) + 1)):
if i%x==0:
break
else:
print(i)
i += 1
Here is what I have:
def is_prime(num):
if num < 2: return False
elif num < 4: return True
elif not num % 2: return False
elif num < 9: return True
elif not num % 3: return False
else:
for n in range(5, int(math.sqrt(num) + 1), 6):
if not num % n:
return False
elif not num % (n + 2):
return False
return True
It's pretty fast for large numbers, as it only checks against already prime numbers for divisors of a number.
Now if you want to generate a list of primes, you can do:
# primes up to 'max'
def primes_max(max):
yield 2
for n in range(3, max, 2):
if is_prime(n):
yield n
# the first 'count' primes
def primes_count(count):
counter = 0
num = 3
yield 2
while counter < count:
if is_prime(num):
yield num
counter += 1
num += 2
using generators here might be desired for efficiency.
And just for reference, instead of saying:
one = 1
while one == 1:
# do stuff
you can simply say:
while 1:
#do stuff
To my opinion it is always best to take the functional approach,
So I create a function first to find out if the number is prime or not then use it in loop or other place as necessary.
def isprime(n):
for x in range(2,n):
if n%x == 0:
return False
return True
Then run a simple list comprehension or generator expression to get your list of prime,
[x for x in range(1,100) if isprime(x)]
Another simple example, with a simple optimization of only considering odd numbers. Everything done with lazy streams (python generators).
Usage: primes = list(create_prime_iterator(1, 30))
import math
import itertools
def create_prime_iterator(rfrom, rto):
"""Create iterator of prime numbers in range [rfrom, rto]"""
prefix = [2] if rfrom < 3 and rto > 1 else [] # include 2 if it is in range separately as it is a "weird" case of even prime
odd_rfrom = 3 if rfrom < 3 else make_odd(rfrom) # make rfrom an odd number so that we can skip all even nubers when searching for primes, also skip 1 as a non prime odd number.
odd_numbers = (num for num in xrange(odd_rfrom, rto + 1, 2))
prime_generator = (num for num in odd_numbers if not has_odd_divisor(num))
return itertools.chain(prefix, prime_generator)
def has_odd_divisor(num):
"""Test whether number is evenly divisable by odd divisor."""
maxDivisor = int(math.sqrt(num))
for divisor in xrange(3, maxDivisor + 1, 2):
if num % divisor == 0:
return True
return False
def make_odd(number):
"""Make number odd by adding one to it if it was even, otherwise return it unchanged"""
return number | 1
This is my implementation. Im sure there is a more efficient way, but seems to work. Basic flag use.
def genPrime():
num = 1
prime = False
while True:
# Loop through all numbers up to num
for i in range(2, num+1):
# Check if num has remainder after the modulo of any previous numbers
if num % i == 0:
prime = False
# Num is only prime if no remainder and i is num
if i == num:
prime = True
break
if prime:
yield num
num += 1
else:
num += 1
prime = genPrime()
for _ in range(100):
print(next(prime))
Just studied the topic, look for the examples in the thread and try to make my version:
from collections import defaultdict
# from pprint import pprint
import re
def gen_primes(limit=None):
"""Sieve of Eratosthenes"""
not_prime = defaultdict(list)
num = 2
while limit is None or num <= limit:
if num in not_prime:
for prime in not_prime[num]:
not_prime[prime + num].append(prime)
del not_prime[num]
else: # Prime number
yield num
not_prime[num * num] = [num]
# It's amazing to debug it this way:
# pprint([num, dict(not_prime)], width=1)
# input()
num += 1
def is_prime(num):
"""Check if number is prime based on Sieve of Eratosthenes"""
return num > 1 and list(gen_primes(limit=num)).pop() == num
def oneliner_is_prime(num):
"""Simple check if number is prime"""
return num > 1 and not any([num % x == 0 for x in range(2, num)])
def regex_is_prime(num):
return re.compile(r'^1?$|^(11+)\1+$').match('1' * num) is None
def simple_is_prime(num):
"""Simple check if number is prime
More efficient than oneliner_is_prime as it breaks the loop
"""
for x in range(2, num):
if num % x == 0:
return False
return num > 1
def simple_gen_primes(limit=None):
"""Prime number generator based on simple gen"""
num = 2
while limit is None or num <= limit:
if simple_is_prime(num):
yield num
num += 1
if __name__ == "__main__":
less1000primes = list(gen_primes(limit=1000))
assert less1000primes == list(simple_gen_primes(limit=1000))
for num in range(1000):
assert (
(num in less1000primes)
== is_prime(num)
== oneliner_is_prime(num)
== regex_is_prime(num)
== simple_is_prime(num)
)
print("Primes less than 1000:")
print(less1000primes)
from timeit import timeit
print("\nTimeit:")
print(
"gen_primes:",
timeit(
"list(gen_primes(limit=1000))",
setup="from __main__ import gen_primes",
number=1000,
),
)
print(
"simple_gen_primes:",
timeit(
"list(simple_gen_primes(limit=1000))",
setup="from __main__ import simple_gen_primes",
number=1000,
),
)
print(
"is_prime:",
timeit(
"[is_prime(num) for num in range(2, 1000)]",
setup="from __main__ import is_prime",
number=100,
),
)
print(
"oneliner_is_prime:",
timeit(
"[oneliner_is_prime(num) for num in range(2, 1000)]",
setup="from __main__ import oneliner_is_prime",
number=100,
),
)
print(
"regex_is_prime:",
timeit(
"[regex_is_prime(num) for num in range(2, 1000)]",
setup="from __main__ import regex_is_prime",
number=100,
),
)
print(
"simple_is_prime:",
timeit(
"[simple_is_prime(num) for num in range(2, 1000)]",
setup="from __main__ import simple_is_prime",
number=100,
),
)
The result of running this code show interesting results:
$ python prime_time.py
Primes less than 1000:
[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, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
Timeit:
gen_primes: 0.6738066330144648
simple_gen_primes: 4.738092333020177
is_prime: 31.83770858097705
oneliner_is_prime: 3.3708438930043485
regex_is_prime: 8.692703998007346
simple_is_prime: 0.4686249239894096
So I can see that we have right answers for different questions here; for a prime number generator gen_primes looks like the right answer; but for a prime number check, the simple_is_prime function is better suited.
This works, but I am always open to better ways to make is_prime function.
You need to make sure that all possible divisors don't evenly divide the number you're checking. In this case you'll print the number you're checking any time just one of the possible divisors doesn't evenly divide the number.
Also you don't want to use a continue statement because a continue will just cause it to check the next possible divisor when you've already found out that the number is not a prime.
This seems homework-y, so I'll give a hint rather than a detailed explanation. Correct me if I've assumed wrong.
You're doing fine as far as bailing out when you see an even divisor.
But you're printing 'count' as soon as you see even one number that doesn't divide into it. 2, for instance, does not divide evenly into 9. But that doesn't make 9 a prime. You might want to keep going until you're sure no number in the range matches.
(as others have replied, a Sieve is a much more efficient way to go... just trying to help you understand why this specific code isn't doing what you want)
You can create a list of primes using list comprehensions in a fairly elegant manner. Taken from here:
>>> noprimes = [j for i in range(2, 8) for j in range(i*2, 50, i)]
>>> primes = [x for x in range(2, 50) if x not in noprimes]
>>> print primes
>>> [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]
How about this if you want to compute the prime directly:
def oprime(n):
counter = 0
b = 1
if n == 1:
print 2
while counter < n-1:
b = b + 2
for a in range(2,b):
if b % a == 0:
break
else:
counter = counter + 1
if counter == n-1:
print b
Similar to user107745, but using 'all' instead of double negation (a little bit more readable, but I think same performance):
import math
[x for x in xrange(2,10000) if all(x%t for t in xrange(2,int(math.sqrt(x))+1))]
Basically it iterates over the x in range of (2, 100) and picking only those that do not have mod == 0 for all t in range(2,x)
Another way is probably just populating the prime numbers as we go:
primes = set()
def isPrime(x):
if x in primes:
return x
for i in primes:
if not x % i:
return None
else:
primes.add(x)
return x
filter(isPrime, range(2,10000))
import time
maxnum=input("You want the prime number of 1 through....")
n=2
prime=[]
start=time.time()
while n<=maxnum:
d=2.0
pr=True
cntr=0
while d<n**.5:
if n%d==0:
pr=False
else:
break
d=d+1
if cntr==0:
prime.append(n)
#print n
n=n+1
print "Total time:",time.time()-start
For me, the below solution looks simple and easy to follow.
import math
def is_prime(num):
if num < 2:
return False
for i in range(2, int(math.sqrt(num) + 1)):
if num % i == 0:
return False
return True
If you wanted to find all the primes in a range you could do this:
def is_prime(num):
"""Returns True if the number is prime
else False."""
if num == 0 or num == 1:
return False
for x in range(2, num):
if num % x == 0:
return False
else:
return True
num = 0
itr = 0
tot = ''
while itr <= 100:
itr = itr + 1
num = num + 1
if is_prime(num) == True:
print(num)
tot = tot + ' ' + str(num)
print(tot)
Just add while its <= and your number for the range.
OUTPUT:
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
Using generator:
def primes(num):
if 2 <= num:
yield 2
for i in range(3, num + 1, 2):
if all(i % x != 0 for x in range(3, int(math.sqrt(i) + 1))):
yield i
Usage:
for i in primes(10):
print(i)
2, 3, 5, 7
The continue statement looks wrong.
You want to start at 2 because 2 is the first prime number.
You can write "while True:" to get an infinite loop.
def genPrimes():
primes = [] # primes generated so far
last = 1 # last number tried
while True:
last += 1
for p in primes:
if last % p == 0:
break
else:
primes.append(last)
yield last
def check_prime(x):
if (x < 2):
return 0
elif (x == 2):
return 1
t = range(x)
for i in t[2:]:
if (x % i == 0):
return 0
return 1
This is the fastest way to find primes up to n that I have seen. Up to 100m in 1.2 seconds.
It uses pure python without dependencies
def primes(lim):
if lim<7:
if lim<2: return []
if lim<3: return [2]
if lim<5: return [2, 3]
return [2, 3, 5]
n = (lim-1)//30
m = n+1
BA = bytearray
prime1 = BA([1])*m
prime7 = BA([1])*m
prime11 = BA([1])*m
prime13 = BA([1])*m
prime17 = BA([1])*m
prime19 = BA([1])*m
prime23 = BA([1])*m
prime29 = BA([1])*m
prime1[0] = 0
i = 0
try:
while 1:
if prime1[i]:
p = 30*i+1
l = i*(p+1)
prime1[l::p] = BA(1+(n-l)//p)
l += i*6
prime7[l::p] = BA(1+(n-l)//p)
l += i*4
prime11[l::p] = BA(1+(n-l)//p)
l += i*2
prime13[l::p] = BA(1+(n-l)//p)
l += i*4
prime17[l::p] = BA(1+(n-l)//p)
l += i*2
prime19[l::p] = BA(1+(n-l)//p)
l += i*4
prime23[l::p] = BA(1+(n-l)//p)
l += i*6
prime29[l::p] = BA(1+(n-l)//p)
if prime7[i]:
p = 30*i+7
l = i*(p+7)+1
prime19[l::p] = BA(1+(n-l)//p)
l += i*4+1
prime17[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime1[l::p] = BA(1+(n-l)//p)
l += i*4
prime29[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime13[l::p] = BA(1+(n-l)//p)
l += i*4+1
prime11[l::p] = BA(1+(n-l)//p)
l += i*6+1
prime23[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime7[l::p] = BA(1+(n-l)//p)
if prime11[i]:
p = 30*i+11
l = i*(p+11)+4
prime1[l::p] = BA(1+(n-l)//p)
l += i*2
prime23[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime7[l::p] = BA(1+(n-l)//p)
l += i*2
prime29[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime13[l::p] = BA(1+(n-l)//p)
l += i*6+2
prime19[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime11[l::p] = BA(1+(n-l)//p)
l += i*6+2
prime17[l::p] = BA(1+(n-l)//p)
if prime13[i]:
p = 30*i+13
l = i*(p+13)+5
prime19[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime11[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime7[l::p] = BA(1+(n-l)//p)
l += i*4+1
prime29[l::p] = BA(1+(n-l)//p)
l += i*6+3
prime17[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime13[l::p] = BA(1+(n-l)//p)
l += i*6+3
prime1[l::p] = BA(1+(n-l)//p)
l += i*4+1
prime23[l::p] = BA(1+(n-l)//p)
if prime17[i]:
p = 30*i+17
l = i*(p+17)+9
prime19[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime23[l::p] = BA(1+(n-l)//p)
l += i*4+3
prime1[l::p] = BA(1+(n-l)//p)
l += i*6+3
prime13[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime17[l::p] = BA(1+(n-l)//p)
l += i*6+3
prime29[l::p] = BA(1+(n-l)//p)
l += i*4+3
prime7[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime11[l::p] = BA(1+(n-l)//p)
if prime19[i]:
p = 30*i+19
l = i*(p+19)+12
prime1[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime17[l::p] = BA(1+(n-l)//p)
l += i*6+4
prime11[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime19[l::p] = BA(1+(n-l)//p)
l += i*6+4
prime13[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime29[l::p] = BA(1+(n-l)//p)
l += i*2+2
prime7[l::p] = BA(1+(n-l)//p)
l += i*4+2
prime23[l::p] = BA(1+(n-l)//p)
if prime23[i]:
p = 30*i+23
l = i*(p+23)+17
prime19[l::p] = BA(1+(n-l)//p)
l += i*6+5
prime7[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime23[l::p] = BA(1+(n-l)//p)
l += i*6+5
prime11[l::p] = BA(1+(n-l)//p)
l += i*4+3
prime13[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime29[l::p] = BA(1+(n-l)//p)
l += i*4+4
prime1[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime17[l::p] = BA(1+(n-l)//p)
if prime29[i]:
p = 30*i+29
l = i*(p+29)+28
prime1[l::p] = BA(1+(n-l)//p)
l += i*2+1
prime29[l::p] = BA(1+(n-l)//p)
l += i*6+6
prime23[l::p] = BA(1+(n-l)//p)
l += i*4+4
prime19[l::p] = BA(1+(n-l)//p)
l += i*2+2
prime17[l::p] = BA(1+(n-l)//p)
l += i*4+4
prime13[l::p] = BA(1+(n-l)//p)
l += i*2+2
prime11[l::p] = BA(1+(n-l)//p)
l += i*4+4
prime7[l::p] = BA(1+(n-l)//p)
i+=1
except:
pass
RES = [2, 3, 5]
A = RES.append
ti=0
try:
for i in range(n):
if prime1[i]:
A(ti+1)
if prime7[i]:
A(ti+7)
if prime11[i]:
A(ti+11)
if prime13[i]:
A(ti+13)
if prime17[i]:
A(ti+17)
if prime19[i]:
A(ti+19)
if prime23[i]:
A(ti+23)
if prime29[i]:
A(ti+29)
ti+=30
except:
pass
if prime1[n] and (30*n+1)<=lim:
A(30*n+1)
if prime7[n] and (30*n+7)<=lim:
A(30*n+7)
if prime11[n] and (30*n+11)<=lim:
A(30*n+11)
if prime13[n] and (30*n+13)<=lim:
A(30*n+13)
if prime17[n] and (30*n+17)<=lim:
A(30*n+17)
if prime19[n] and (30*n+19)<=lim:
A(30*n+19)
if prime23[n] and (30*n+23)<=lim:
A(30*n+23)
if prime29[n] and (30*n+29)<=lim:
A(30*n+29)
return RES
from time import time
n = time()
print (primes(100000000)[-1])
print (time() - n)
Related
The question is this :
Write a Python function to find all the Strong numbers in a given list of numbers.
Write another function to find and return the factorial of a number. Use it to solve the problem.
Note: 0!=1
The code I tried so far :
def factorial(number):
sum1=0
temp=number
while(number):
i=1
f=1
r=number%10
while(i<=r):
f=f*i
i=i+1
sum1=sum1+f
number=number//10
return sum1
return temp
def find_strong_numbers(num_list):
for item in num_list:
for number in range(1,item+1):
if(sum1==temp):
print(number)
num_list=[145,375,100,2,10]
strong_num_list=find_strong_numbers(num_list)
print(strong_num_list)
Expected output : [145, 2]
I am facing error which is :
NameError: name 'sum1' is not defined
import math
def factorial(number):
if number == 0:
return 1
else:
return number * factorial(number-1)
def find_strong_numbers(num_list):
strongNumbersList = []
for item in num_list:
currentNumber = item
digits = []
while currentNumber > 0:
digits.insert(0, currentNumber % 10)
currentNumber = currentNumber // 10
if sum(map(factorial, digits)) == item:
strongNumbersList.append(item)
return strongNumbersList
num_list=[145,375,100,2,10]
strong_num_list=find_strong_numbers(num_list)
print(strong_num_list)
import math
def factorial(number):
if number == 0:
return 1
else:
return number * factorial(number-1)
def find_strong_numbers(num_list):
strongNumbersList = []
for item in num_list:
currentNumber = item
digits = []
while currentNumber > 0:
digits.insert(0, currentNumber % 10)
currentNumber = currentNumber // 10
if sum(map(factorial, digits)) == item:
if item==0:
break
strongNumbersList.append(item)
return strongNumbersList
num_list=[145,375,100,2,10,40585,0]
strong_num_list=find_strong_numbers(num_list)
print(strong_num_list)
List item
def bubble_sort(alist):
i = 0
j = 0
while i<len(alist):
while j<(len(alist)-1-i):
if alist[j]>alist[j+1]:
temp = alist[j]
alist[j] = alist[j+1]
alist[j+1] = temp
j = j+1
i = i + 1
return alist
abc = [54,26,93,17,77,31,44,55,20]
alist1 = bubble_sort(abc)
print(alist1)
I have no idea why this only undergoes one pass. Can someone pls help??
You just have to move the initialization j=0 inside the first while loop, as follows. Note that you can also swap two values in a shorter way in Python, as I did:
def bubble_sort(a):
i = 0
while i<len(a):
j = 0
while j<(len(a)-1-i):
if a[j]>a[j+1]:
a[j], a[j+1] = a[j+1], a[j]
j = j+1
i = i + 1
return a
abc = [54,26,93,17,77,31,44,55,20]
alist1 = bubble_sort(abc)
print(alist1) # [17, 20, 26, 31, 44, 54, 55, 77, 93]
I have the following code for calulating the GCD of two numbers:
def gcd(m, n):
r = m % n
while r != 0:
m = n
n = r
r = m % n
return n
print ("\n", "gcd (10, 35) = ", gcd(10, 35))
print ("\n", "gcd (735, 175) = ", gcd(735, 175))
print ("\n", "gcd (735, 350) = ", gcd(735, 350))
I would like to count the number of iterations that the algorithm has to go through before finding the GCD. I am having trouble making a for loop to determine the number of iterations.
def gcd(m, n):
r = m % n
counter = 0
while r != 0:
m = n
n = r
r = m % n
counter += 1
return n, counter
This python code is returning a ValueError in the random number generator section of the code. I ran it with hardcoded values in the function: def fermat_test(n): at line
a = random.randit(2,n-1), and it seemed to run otherwise. I can't figure out why the range is out of bounds?
import random
def remainder(i,j):
rem = i%j
return rem
def is_even(n): return n % 2 == 0
def square(n): return n**2
def expmod(b, e, m):
if e==0:
return 1
elif is_even(e):
expm = expmod(b, e/2,m)
return remainder(expm*expm,m)
else:
return remainder(b*expmod(b,e-1,m),m)
def fermat_test(n):
a = random.randint(2,n-1)
return expmod(a,n,n)==a
def is_fermat_prime(n, ntimes):
if ntimes == 0:
return True
elif fermat_test(n):
return is_fermat_prime(n,ntimes-1)
else:
return False
## this is the test you can use to test your code
def sum_of_fermat_primes(n):
sum = 0
for i in xrange(n+1):
if is_fermat_prime(i, 70):
sum += i
return sum
print sum_of_fermat_primes(10)
print sum_of_fermat_primes(20)
print sum_of_fermat_primes(560)
print sum_of_fermat_primes(570)
Traceback (most recent call last):
File "C:\Users\Terik\.atom\code.py", line 33, in <module>
print sum_of_fermat_primes(10)
File "C:\Users\Terik\.atom\code.py", line 30, in sum_of_fermat_primes
if is_fermat_prime(i, 70):
File "C:\Users\Terik\.atom\code.py", line 22, in is_fermat_prime
elif fermat_test(n):
File "C:\Users\Terik\.atom\code.py", line 17, in fermat_test
a = random.randint(2,n-1)
File "C:\Python27\lib\random.py", line 242, in randint
return self.randrange(a, b+1)
File "C:\Python27\lib\random.py", line 218, in randrange
raise ValueError, "empty range for randrange() (%d,%d, %d)" % (istart, istop, width)
ValueError: empty range for randrange() (2,0, -2)
The error is because in
a = random.randint(2,n-1)
n - 1 is less than 2. In fact, the value of n comes from i in for i in xrange(n+1), so it starts from 0, 1, 2, etc. These smallest values make the random.randint(2,n-1) invalid.
Your i in xrange starts at 0 it should start at 1 instead.
for i in xrange(1, n+1):
i'm working on 8 queen(Genetic Algorithm) program with python 3.4
i use a matrix for keep queens position. but i have an error in sort() function,i dont underestand this error.
please help me ...
my code:
from random import randrange
__author__ = 'Moein'
class NQueen:
NUM_COLS = 8
POPULATIONS = 100
current = [[]]
def __init__(self):
self.current = [[0 for col in range(self.NUM_COLS + 1)] for row in range(self.POPULATIONS)]
# generate first Generation
for i in range(0, self.POPULATIONS):
for j in range(0, self.NUM_COLS):
self.current[i][j] = randrange(self.NUM_COLS)
count = 0
condition = True
while condition:
self.crossover()
self.mutation()
self.fitness()
self.sort()
count += 1
print(self.current)
# print(self.current[0])
if self.current[0][self.NUM_COLS] == 0:
condition = False
print(self.current[0])
pass
def fitness(self):
count = 0
for i in range(0, self.POPULATIONS):
for j in range(0, self.NUM_COLS):
for x in range(j + 1, self.NUM_COLS):
if self.current[i][j] == self.current[i][x]:
count += 1
if abs(j - x) == abs(self.current[i][j] - self.current[i][x]):
count += 1
self.current[i][self.NUM_COLS] = count
count = 0
pass
def sort(self):
for i in range(0, self.POPULATIONS - 1):
for j in range(i + 1, self.POPULATIONS):
if self.current[i][self.NUM_COLS] > self.current[j][self.NUM_COLS]:
for x in range(0, self.NUM_COLS + 1):
temp = self.current[i][x]
self.current[i][x] = self.current
self.current[j][x] = temp
pass
def crossover(self):
_new = [[0 for x in range(self.NUM_COLS + 1)] for x in range(self.POPULATIONS)]
for i in range(0, int(self.POPULATIONS / 2)):
for j in range(0, int(self.NUM_COLS / 2)):
_new[i + 49][j] = self.current[i][j]
_new[i + 49 + 1][j] = self.current[i + 1][j]
for j in range(int(self.NUM_COLS / 2), self.NUM_COLS):
_new[i + 49][j] = self.current[i][j]
_new[i + 49 + 1][j] = self.current[i + 1][j]
self.current = _new
pass
def mutation(self):
for i in range(0, self.POPULATIONS):
self.current[i][randrange(self.NUM_COLS)] = randrange(self.NUM_COLS)
pass
nQueen = NQueen()
print(nQueen.current[0])
and my error:
Traceback (most recent call last):
File "C:/Users/Moein/PycharmProjects/NQueen/project.py", line 81, in <module>
nQueen = NQueen()
File "C:/Users/Moein/PycharmProjects/NQueen/project.py", line 27, in __init__
self.sort()
File "C:/Users/Moein/PycharmProjects/NQueen/project.py", line 54, in sort
if self.current[i][self.NUM_COLS] > self.current[j][self.NUM_COLS]:
TypeError: unorderable types: list() > int()
self.current[i][x] = self.current
I guess that its this line causing the problem, since
self.current
is a list, so you are setting
self.current[i][x]
to be a list instead of an int. So at this point:
if self.current[i][self.NUM_COLS] > self.current[j][self.NUM_COLS]:
when you try to compare those values it might happen, that you compare
an int with a list, which causes the error.
TypeError: unorderable types: list() > int()
Cheers
EDIT:
I just tried it out.
Replacing
self.current
with an int for example 2 prevents the Exception from occurring.