def tryit(special,memo={}): print special if special in memo: return memo[special] memo[special]= None result = None for prime in p.primes_list: count = 0 if prime in special: continue for s in special: if p.is_prime(p.concat_nums(prime,s)): if p.is_prime(p.concat_nums(s,prime)): count +=1 if count == len(special): result = special+(prime,) break if result == None: for i in range(len(special)): for prime in p.primes_list[1:]: if prime not in special: result = tryit(special[:i]+(prime,) +special[i+1:]) if result: print result break if result: break memo[special] = result return memo[special]
def main(n): primes.init(10**6) nums = [1,3,7,9,13,27] offnums = [11,17,19,21,23] total = 0 failure = False #below is the only intelligent part #look at each of the numbers modulo 5 #and we can eliminate all possibilities for #n^2 except for n mod 5 = 0. for x in xrange(10,n,10): square = x*x if (((x % 3) not in (1,2)) or ((x % 7) not in (3,4))): continue for offset in nums: if not primes.is_prime(square+offset): failure = True break if failure: failure = False continue for offset in offnums: if primes.is_prime(square+offset): failure = True break if not failure: print "Yay",x total += x failure = False print total
def generateMSecure(pi_i): # Choose random "semi-safe" prime Q_0 = 2(q_0)(pi_i) + 1 # and random "semi-safe" prime Q_1 = 2d(q_1) + 1 # then m = (Q_0)(Q_1) # Security requirements: # pi_i < m^(1/4) # For testing we'll start with q0 = primes[10000] and Q1 = primes[10700] # this is NOT GOOD for security # d & q1 need to be chosen uniformally from a large interval # Note also that m must be within [2k , 2(k+1)] for security (since it's the order of G) d = primes.primes[150] Q0 = 4 i = 100 while not primes.is_prime(int(Q0)): q_0 = primes.primes[i] i = i + 1 Q0 = 2 * (q_0) * (pi_i) + 1 Q1 = 4 i = 107 while not primes.is_prime(Q1): q_1 = primes.primes[i] i = i + 1 Q1 = 2 * d * (q_1) + 1 m = Q0 * Q1 return m
def enumerate_digits(n_fixed,digit,k): result = [0]*k #pick empty slots final_result = [] if n_fixed == k: num = int(str(digit)*k) if primes.is_prime(num): return [num] return [] for slots in it.combinations(range(k),n_fixed): for num in xrange(10**(k-n_fixed)): i = 0 astr = str(num) astr = '0'*(k-n_fixed-len(astr))+astr for spot in range(k): if spot in slots: result[spot] = str(digit) else: result[spot] = astr[i] i+=1 num =int("".join(result)) if len(str(num)) != len(result): continue if primes.is_prime(num): final_result.append(num) return final_result
def answer(): i = 7 while True: i += 2 if not(p.is_prime(i)): for s in yield_while(get_squares, lambda x: x<i): if p.is_prime(i-s): break else: return i
def is_concat(p1,p2,misconcat={}): if (p1,p2) in misconcat: return misconcat[(p1,p2)] misconcat[(p1,p2)]=False if (pr.is_prime(pr.concat_nums(p1,p2)) and pr.is_prime(pr.concat_nums(p2,p1))): misconcat[(p1,p2)] = True misconcat[(p2,p1)] = True return misconcat[(p1,p2)]
def is_trunc(list_num): num = "".join(map(str, list_num)) # turn (1, 2, 3) into 123 if is_prime(int(num)): primes.append(int(num)) for k in range(1, len(num)): if not is_prime(int(num[k:])) or not is_prime(int(num[:k])): return False return True return False
def p060(): # (13, 5197, 5701, 6733, 8389) is_prime(1000000) g = tup1_gen() g = tup_gen(g) g = tup_gen(g) g = tup_gen(g) return sum(g.next())
def test_is_prime_22(self): """Test if is_prime throw an exception when passed an even number as argument. """ try: primes.is_prime([3, 5, 7, 11], 22) except AssertionError: pass else: self.fail('AssertionError for is_prime(22) not thrown')
def truncatable_prime(p): d = 10 (tl, tr) = (p, p) while tl > 10: tl = p / d tr = p % d if not is_prime(tl) or not is_prime(tr): return False d *= 10 return True
def problem_forty_nine(): increase = 3330 four_digit_primes = generate_list_of_primes(1000, 9999) for num in four_digit_primes: second = num + increase if second < (10000 - increase) and is_prime(second): third = num + (increase * 2) if third < 10000 and is_prime(third): check_perms(num, second, third)
def follows_property(n): n1 = n + 3330 n2 = n1 + 3330 if is_prime(n1) and is_prime(n2): digits_n = [int(x) for x in str(n)] digits_n1 = [int(x) for x in str(n1)] digits_n2 = [int(x) for x in str(n2)] if sorted(str(n)) == sorted(str(n1)) == sorted(str(n2)): return [n, n1, n2] else: return False
def prob_046(): #TODO Refactor for i in count(9, 2): if primes.is_prime(i): continue for j in count(1): temp = i - 2 * j ** 2 if temp < 0: return i if primes.is_prime(temp): break
def test_is_prime(self): # Let's just check all the most important numbers self.assertFalse(is_prime(0)) self.assertFalse(is_prime(1)) self.assertTrue(is_prime(2)) self.assertTrue(is_prime(5)) self.assertFalse(is_prime(35)) self.assertTrue(is_prime(101)) self.assertFalse(is_prime(1001)) self.assertTrue(is_prime(1009)) self.assertTrue(is_prime(2017)) self.assertFalse(is_prime(2021))
def test3_large_positive_random_integers(self, x): """Randomly picked integers in the range [0, 1 000 000].""" if model_is_prime(x): self.assertTrue( is_prime(x), "{} is a prime number but your function says it is not.". format(x)) else: self.assertFalse( is_prime(x), "{} is not a prime number but your function says it is.". format(x))
def is_truncatable_prime(number): if number < 10: return False left = str(number) right = str(number) while len(left) > 0: if not is_prime(int(left)) or not is_prime(int(right)): return False left, right = left[:-1], right[1:] return True
def test_is_prime_validation(): # Checking for an exception long way... try: is_prime('a') assert False, 'should not have reached here' except RuntimeError as exc: assert str(exc) == 'not an integer' # ...And the short way. with pytest.raises(RuntimeError) as exc: is_prime('a') assert str(exc.value) == 'not an integer'
def test_is__prime_with_small_set(self): """is_prime returns True for prime numbers and False for non-prime numbers in range [100, 200]""" for i in range(100, 201): if model_is_prime(i): self.assertTrue( is_prime(i), "{} is a prime number but your function says it is not.". format(i)) else: self.assertFalse( is_prime(i), "{} is not a prime number but your function says it is.". format(i))
def solve46(): n = 9 while True: if n % 2 != 0 and not primes.is_prime(n): goldbach = False for x in range(1, int(math.sqrt((n+1)/2))+2): twice_square = 2*x*x if twice_square < n: if primes.is_prime(n-twice_square): goldbach = True if not goldbach: return n n += 1
def max_prime(x): maxim = 0 if x % 2 == 0: maxim = 2 if x % 3 == 0: maxim = 3 for i in range(6, int(math.sqrt(x)), 6): if x % (i - 1) == 0 and is_prime(i - 1): maxim = i - 1 if x % (i + 1) == 0 and is_prime(i + 1): maxim = i + 1 return maxim
def test2_small_positive_integers(self): """Integers in the range [100, 200].""" for x in range(100, 201): if model_is_prime(x): self.assertTrue( is_prime(x), "{} is a prime number but your function says it is not.". format(x)) else: self.assertFalse( is_prime(x), "{} is not a prime number but your function says it is.". format(x))
def test_is__prime_with_large_set(self, i): """is_prime returns True for prime numbers and False for non-prime numbers for 1000 random positive integers in range(0, 10**6).""" if model_is_prime(i): self.assertTrue( is_prime(i), "{} is a prime number but your function says it is not.". format(i)) else: self.assertFalse( is_prime(i), "{} is not a prime number but your function says it is.". format(i))
def p35(): circular_primes = [] for n in range(2, 1000000): if not n in circular_primes: if primes.is_prime(n): rots = listmath.rotations(n) prime = True for rot in rots: if not primes.is_prime(rot): prime = False break if prime: circular_primes += rots return len(set(circular_primes))
def truncatable(n): if n < 10: return False x = n // 10 while x: if not is_prime(x): return False x //= 10 s = str(n)[1:] while s: if not is_prime(int(s)): return False s = s[1:] return True
def factors(argument): """Factor an integer into a list of primes.""" if is_prime(argument): return [argument] answer = [] i = 2 while argument > 1 and not is_prime(argument): while argument % i == 0: answer.append(i) argument /= i i += 1 if argument > 1: answer.append(argument) return answer
def test_negative_number1(self): """Is a negative number correctly determined not to be prime?""" self.assertFalse(is_prime(-1)) self.assertFalse(is_prime(-2)) self.assertFalse(is_prime(-3)) self.assertFalse(is_prime(-4)) self.assertFalse(is_prime(-5)) self.assertFalse(is_prime(-6)) self.assertFalse(is_prime(-7)) self.assertFalse(is_prime(-8)) self.assertFalse(is_prime(-9))
def get_RSA_keys(bit_len, p=None, q=None): if p and q: if p == q: raise Exception('Numbers must be different') if (not is_prime(p)) or (not is_prime(q)): raise Exception('Numbers must be primes') if p is None: p = generate_large_prime(bit_len) if q is None: q = generate_large_prime(bit_len) n = p * q phi = get_phi(p, q) e = generate_public_key(phi) d = generate_private_key(e, phi) return (e, n), (d, n)
def main(): n = 1 while True: n += 2 if not is_prime(n) and not is_decomposable(n): print(n) break
def __init__(self, a=101): self.h = 0 if not is_prime(a): raise ValueError('a must be prime') self.a = a self.history = queue.deque() self.size = 0
def spriral(n,primes): fraction = 1.0 result = [0.0,0] total = 1 prior = 1 p_count = 0 z = 0 for i in xrange(3,n,2): total +=4 for t in xrange(0,4): if t % 4 == 0: z +=2 prior += z if prior in primes: p_count +=1 elif prior > 100000000: if p.is_prime(prior): p_count +=1 primes.add(prior) fraction = 1.*p_count/total if fraction < 0.1: result = [fraction,i] break result = [fraction,i] return result , prior, z , len(primes)
def test_negative_number(self): '''Is a negative number correctly determined not to be prime?''' for index in range(-1, -10, -1): self.assertFalse( is_prime(index), msg='{} should not be determined to be prime'.format(index))
def prime_order_point(self): prime_order_points = [ point for point in self.orders if primes.is_prime(self.orders[point]) ] point = max(prime_order_points, key=lambda p: self.orders[p]) return point
def odd_composites(): "Generate the series of odd composite numbers." n = 9 while True: if n % 2 == 1 and not is_prime(n): yield n n += 1
def check_right(n): while n != 0: if not is_prime(n): return False n = n // 10 return True
def is_e_valid(p, q, e): totient = (p - 1) * (q - 1) if e >= totient: return False elif are_coprimes(e, totient) and is_prime(e): return True return False
def is_circular(p): digits = str(p) for _ in range(1,len(digits)): digits = digits[1:] + digits[:1] if not is_prime(int(digits)): return False return True
def goldbach(n): """Tries to find a number s so that n = p + 2*s^2, where p is a prime""" for s in range(n): p = n - 2 * s * s if is_prime(p): return s return None
def solution(): for length in range(9,0,-1): digits = '987654321'[-length:] for pandigital in itertools.permutations(digits): pandigital = int(''.join(pandigital)) if is_prime(pandigital): return pandigital
def print_next_prime(number): index = number while True: index += 1 if is_prime(index): print(index)
def insert(nonanswer): global non_answers if nonanswer == nonanswer/2*2: return if primes.is_prime(nonanswer): return non_answers.append(nonanswer)
def print_next_prime(number): """Print the closest prime number larger than *number*.""" index = number while True: index += 1 if is_prime(index): print(index)
def main(): LIMIT = 10**6 primes = sieve_of_eratosthenes(LIMIT) cumulative_sums = [2 for i in primes] for i in range(1, len(cumulative_sums)): cumulative_sums[i] = primes[i] + cumulative_sums[i-1] result = 0 number_of_primes = 0 for i in range(0, len(cumulative_sums)): for j in range(i - (number_of_primes + 1), -1, -1): sum_consecutive_primes = cumulative_sums[i] - cumulative_sums[j] # sum_consecutive_primes increases as the inner loop advances. If # the difference is already too large, we can break the loop, since # it will only grow larger if sum_consecutive_primes > LIMIT: break if is_prime(sum_consecutive_primes): number_of_primes = i - j result = sum_consecutive_primes print(result) return
def goldbach(n): """Tries to find a number s so that n = p + 2*s^2, where p is a prime""" for s in range(n): p = n - 2*s*s if is_prime(p): return s return None
def sumaprimes(lista): contador = 0 for i in lista: if (primes.is_prime(i)): print(i) contador += i return contador
def runTest(self): self.assertEqual(primes.between_primes(1, 10), [2, 3, 5, 7]) self.assertEqual(primes.between_primes(5, 5), []) self.assertEqual(primes.between_primes(257, 347), [ 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337 ]) self.assertRaises(ValueError, primes.between_primes('3', '6')) self.assertRaises(ValueError, primes.between_primes('', '')) self.assertRaises(ValueError, primes.between_primes('3', 5)) self.assertRaises(ValueError, primes.between_primes(5, '3')) self.assertRaises(ValueError, primes.between_primes('e', 6)) self.assertFalse(primes.is_prime(49)) self.assertFalse(primes.is_prime(1)) self.assertRaises(primes.RangeError, primes.between_primes(10, 5))
def primes_row(a,b): n = 0 count = 0 while is_prime(n**2 + a * n + b): count += 1 n += 1 return count-1
def solve(num): primes = [2, 3, 5, 7, 11, 13, 17, 19] i = 0 while True: if i >= len(primes): p = primes[-1] + 2 while not is_prime(p): p += 2 primes.append(p) if num % primes[i] == 0: num //= primes[i] i = 0 if is_prime(num): break else: i += 1 return num
def prob_037(): total, nums = 0, 0 for i in count(9, 2): if is_prime(i) and check1(i) and check2(i): nums += 1 total += i if nums == 11: return total
def twin_primes(start, end): lst = [] for x in range(start, end + 1): if primes.is_prime(x) and primes.__is_prime(x + 2): lst.append(tuple([x, x + 2])) return lst
def count_seq_length(a, b): n = 0 while True: v = f(a, b, n) if not is_prime(v): break n = n + 1 return n
def count_primes(f): """Determine how many primes can be created using this format.""" ret_list = [] for c in "0123456789": temp = f.replace('*', c) if primes.is_prime(int(temp), primes_list) and temp[0] != '0': ret_list.append(temp) return ret_list
def test1_negative_integers(self): """Integers in the range [-100, 0).""" # Arbitrary unittest test method body for x in range(-100, 0, 5): self.assertFalse( is_prime(x), "{} is not a prime number but your function says it is.". format(x))
def GenereateRemarkables(remarkable): curr_len = len(remarkable) if curr_len >= remarkable_len_max: print 'Answer:', sum(remarkable), remarkable exit() for p in primes_list: if curr_len > 0 and p < remarkable[curr_len - 1]: continue for r in remarkable: if not primes.is_prime(int(str(r) + str(p))): break if not primes.is_prime(int(str(p) + str(r))): break else: copy = list(remarkable) copy.append(p) GenereateRemarkables(copy)
def consecutive_quadratic_primes(a, b): """ Returns the amount of consecutive prime yielded by n**2 + an + b by counting forward, from n = 0 """ for n in count(start=0): if not is_prime(n**2 + a * n + b): return n
def test_is_prime_with_no_primes(self): """is_prime returns False for non-prime numbers""" values = [-1, 0, 1, 4, 6, 8, 9, 10, 12, 14] for value in values: self.assertFalse( is_prime(value), "{:d} is not a prime number, but your function says it is".format(value) )
def test_is_prime_with_only_primes(self): """is_prime returns True for prime numbers""" values = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] for value in values: self.assertTrue( is_prime(value), "{:d} is a prime number, but your function says it is not".format(value) )
def palindromic_primes(start, end): lst = [] for x in range(start, end + 1): if primes.is_prime(x): if str(x)[::-1] == str(x): lst.append(x) return lst
def check_left(n): d = 10 m = n % d while m != n: if not is_prime(m): return False d = d * 10 m = n % d return True
def generate_keys(p, q): if not is_prime(p) or not is_prime(q) or p == q: raise ValueError("p and q must be distinct prime numbers") n = p * q phi_n = (p - 1) * (q - 1) # use public exponent of 2^(16) + 1 since it is the most common value. if # it is not coprime to phi_n, find a new number e = pow(2, 16) + 1 g = gcd(e, phi_n) while g != 1: # try a new odd number 3 <= n < phi_n e = random.randrange(3, phi_n, 2) g = gcd(e, phi_n) # get the multiplicative inverse of e mod phi d = multiplicative_inverse(e, phi_n) return ((e, n), (d, n))