def p37():
prime_numbers = list(primes(740000))
truncatable_prime_list = []
for prime in prime_numbers:
if prime < 10: continue
prime_str = str(prime)
if prime_str[-1] not in ('3', '7'): continue
if prime_str[0] not in ('2', '3', '5', '7'): continue
right_truncatable_prime = False
right_truncated_str = prime_str[:-1]
while len(right_truncated_str) > 0:
right_truncated = int(right_truncated_str)
if is_prime(right_truncated, prime_numbers) == False: break
right_truncated_str = right_truncated_str[:-1]
else:
right_truncatable_prime = True
if right_truncatable_prime == False: continue
left_truncatable_prime = False
left_truncated_str = prime_str[1:]
while len(left_truncated_str) > 0:
left_trucated = int(left_truncated_str)
if is_prime(left_trucated, prime_numbers) == False: break
left_truncated_str = left_truncated_str[1:]
else:
left_truncatable_prime = True
if left_truncatable_prime and right_truncatable_prime:
truncatable_prime_list.append(prime)
return sum(truncatable_prime_list)
def prepare_concat_map(source_primes: list[int],
check_primes: list[int]) -> dict[int, list[int]]:
left_to_right = {}
for prime_pair in combinations(source_primes, 2):
left_prime = str(prime_pair[0])
right_prime = str(prime_pair[1])
left_right_prime = is_prime(int(left_prime + right_prime),
check_primes)
right_left_prime = is_prime(int(right_prime + left_prime),
check_primes)
if left_right_prime and right_left_prime:
left_to_right.setdefault(prime_pair[0], []).append(prime_pair[1])
return left_to_right
def p27(a_start: int, a_stop: int, b_start: int, b_stop: int) -> int:
# b needs to be prime to get a prime when n == 0, so b >= 2
b_start = max(b_start, 2)
# when n == b then all terms are a multiple of b, so this is the
# limit of what needs to be searched
largest_output = (b_stop - 1) * ((b_stop - 1) + (a_stop - 1) + 1)
prime_factors = list(primes(largest_output))
# calcuate offset for start of a: a must be odd, unless b == 2
a_start_even = a_start % 2 == 0
(max_a, max_b, max_n) = (0, 0, 0)
for b in prime_factors:
if b < b_start: continue
if b >= b_stop: break
if a_start_even != (b == 2):
a_start_offset = 1
else:
a_start_offset = 0
for a in range(a_start + a_start_offset, a_stop, 2):
for n in range(0, b):
quadratic_value = n * n + a * n + b
if quadratic_value < 0: break
if not is_prime(quadratic_value, prime_factors): break
if n > max_n:
(max_a, max_b, max_n) = (a, b, n)
return max_a * max_b
def prime_plus_twice_square(num):
i = 1
while num > 2 * (i**2):
candidate = num - 2 * (i**2)
if is_prime(candidate):
return [candidate, i]
else:
i += 1
return []
def is_truncatable_prime(n):
# Single digit primes cannot be truncatable.
if n < 10:
return False
# Calculate left and right truncations.
digits = digit_expansion(n)
truncations = prefixes(digits) + suffixes(digits)
truncations = map(digit_unexpansion, truncations)
# And test truncations are primes.
return all(is_prime(truncation) for truncation in truncations)
def p58(max_ratio: float) -> int:
prime_list = list(primes(1000000))
layer = 0
ratio = 1
prime_count = 0
number_count = 1
while ratio > max_ratio:
layer += 1
for corner_number in range(4):
number = 2 * layer * (2 * (layer - 1) + corner_number + 1) + 1
if is_prime(number, prime_list):
prime_count += 1
number_count += 4
ratio = prime_count / number_count
return 2 * layer + 1
def p35(stop: int) -> int:
circular_primes = set()
primes_to_check = list(primes(stop))
for prime in primes_to_check:
prime_str = str(prime)
prime_len = len(prime_str)
rotated_str = prime_str
rotations = [rotated_str]
prime_rotations = 1
for rotation_number in range(prime_len - 1):
rotated_str = rotate(rotated_str)
rotations.append(rotated_str)
if is_prime(int(rotated_str), primes_to_check):
prime_rotations += 1
else:
break
if prime_rotations == prime_len:
# all rotations are prime
circular_primes.update(rotations)
return len(circular_primes)
def is_circular(n):
'''
Return True if n is a circular prime for n > 0.
'''
return all(is_prime(rotation) for rotation in rotations(n))
bound = bound + 1
array = []
while True:
bound = bound - 1 #narrow maximum width of search
shift = 0 #reinitialize shift
#NOTE: array should not need reinitialized because this code only executes if it's empty
print("bound = ", bound)
while True:
candidate = 0
#add up the primes between index j and bound + j to produce a candidate
for k in range(shift, bound + shift):
candidate = candidate + primes[k]
if candidate <= max and is_prime(candidate): #if candidate meets selection criteria, record it
array.append(candidate)
shift = shift + 1
print(candidate,' - candidate added')
elif candidate <= max:
shift = shift + 1
print(candidate,' - candidate was not prime')
else:
print(candidate,' - candidate overstepped bounds')
break
print('while loop finished', "\n\n")
#detects if the inner loop found any candidates
if len(array) > 0:
array.sort()
largest = array[len(array)-1] #picks out largest element which is prime
candidates = []
final = []
for i in primes:
#takes the current element of primes and outputs a list of all its permutations
current_array = num_to_array(i)
curr_perms_arr = permutations(current_array)
curr_perms = []
for j in range(0,len(curr_perms_arr)):
curr_perms.append(array_to_num(curr_perms_arr[j]))
#determines which if any permutations are prime
prime_perms = []
for j in range(0,len(curr_perms)):
if is_prime(curr_perms[j]) and curr_perms[j] > 1000:
prime_perms.append(curr_perms[j])
#formats list
prime_perms = remove_duplicates(prime_perms)
prime_perms.sort()
if(len(prime_perms)) >= 3:
candidates.append(prime_perms)
candidates = remove_duplicates(candidates)
#find differences among elements of candidates and checks if that difference contains 3330
for i in range(0,len(candidates)):
diff = []
for j in range(0,len(candidates[i])):