def is_concatenated_prime(new, existing):
"""
>>> is_concatenated_prime(7, 109)
True
"""
new_first = int(new * 10**(get_number_length(existing)) + existing)
new_last = int(existing * 10**(get_number_length(new)) + new)
return is_prime(new_first) \
and is_prime(new_last)
def main():
""" challenge077 """
nums = dict()
num = 2
while True:
sums = set()
# Is the current number a prime?
if is_prime(num):
sums.add(tuple([num]))
# Check for previous sums
for num_a in range(2, num // 2 + 1):
num_b = num - num_a
# Collect each a sum to each b sum
for ab_sums in [
sorted(aSum + bSum) for aSum in nums[num_a]
for bSum in nums[num_b]
]:
sums.add(tuple(ab_sums))
nums[num] = sums
if len(sums) > 5000:
return num
num += 1
def main():
""" challenge046 """
odd_composite = 3
while True:
# Find doubled squares lower than odd_composite
if not has_criteria(odd_composite):
return odd_composite
odd_composite += 2
while odd_composite == 1 or is_prime(odd_composite):
odd_composite += 2
def main():
""" challenge041 """
# loop through number of digits
highest = 0
for number_size in [4, 7]:
chars = "".join([str(c) for c in range(1, number_size + 1)])
for potential in [int(p)
for p in permutate(chars)
if is_prime(int(p))]:
# if potential > highest:
# Potential is always higher in this scenario.
highest = potential
return highest
def main():
""" challenge118 """
perms = ["1", "2", "3", "5", "7"]
for size in range(2, 10):
perms.extend([perm for perm in permutations("123456789", size)
if perm[-1] != 2 and perm[-1] != "5"])
perms = ["".join(p) for p in perms]
primes = [prime for prime in perms if is_prime(int(prime))]
sets = build_sets("", primes)
return sets
def has_criteria(potential):
"""
>>> has_criteria(9)
True
>>> has_criteria(5777)
False
"""
limit = int(sqrt(potential // 2))
for square_doubled in [2 * i**2 for i in range(limit, 0, -1)]:
diff = potential - square_doubled
if diff == 1 or is_prime(diff):
return True
return False
def is_truncated_prime(potential):
"""
>>> is_truncated_prime(3797)
True
>>> is_truncated_prime(3798)
False
"""
divisor = 1
# Check first digit is prime
while True:
trunc = potential // divisor
if trunc <= 0:
break
if trunc == 1 or not is_prime(trunc):
return False
divisor *= 10
while (potential % divisor) > 0:
trunc = potential % divisor
if trunc == 1 or not is_prime(potential % divisor):
return False
divisor /= 10
return True
def main():
""" challenge051 """
step = cycle([2, 4])
current = 5
while True:
# Check current
if is_prime(current) and has_3_same_digits(current):
# Substitute 0 to 9
word = str(current)
for i in range(0, 10):
number_of_primes, smallest = substitute_primes(word,
str(i))
if number_of_primes == 8:
return smallest
current += next(step)
def main():
""" challenge111 """
# pylint: disable=invalid-name
M = [8, 9, 8, 9, 9, 9, 9, 9, 8, 9]
S = []
for i in range(10):
s = 0
# use M[i] to build up all possible numbers
for m in [list(("%0" + str(10 - M[i]) + "d") % m)
for m in range(0, 10**(10 - M[i]))]:
if not any(int(c) == i for c in m):
for num in [int("".join(b))
for b in build_nums([str(i)] * M[i], m)]:
if num >= 10**(9) and is_prime(num):
# Check each for primality
s += num
S.append(s)
return sum(S)
def substitute_primes(template, substitute):
"""
>>> substitute_primes("13", "1")
(6, 13)
>>> substitute_primes("56223", "2")
(7, 56003)
"""
count = 0
smallest = int(template)
for i in range(0, 10):
# Swap out the substitute for 0 - 9
working = template.replace(substitute, str(i))
# Check if prime
if working[0] != "0":
working = int(working)
if is_prime(int(working)):
if working < smallest:
smallest = working
count += 1
return count, smallest
def main():
""" challenge058 """
current = 1
prime_count = 0
diagonals = 1
# Cycle through layers
sidestep = 2
while True:
for _ in range(1, 4):
current += sidestep
if is_prime(current):
prime_count += 1
current += sidestep
diagonals += 4
if prime_count * 10 < diagonals:
return sidestep + 1
sidestep += 2
def main():
""" challenge027 """
limit = 999
maximum_a = 0
maximum_b = 0
maximum = 1
primes = list(sieved_primes(limit + 1))
for prime in primes:
for a_side in range(-prime, limit + 1):
root = 1
while True:
potential_prime = root * (root + a_side) + prime
if not is_prime(potential_prime):
break
root += 1
if root > maximum:
maximum = root
maximum_a = a_side
maximum_b = prime
return maximum_a * maximum_b
def test_is_prime(input, expected):
actual = is_prime(input)
expect(actual).to.eq(expected)