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 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 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))
