def solution(thres, verbose=True):
'''
3x3
1 3 5 7 9
total diag elems = 5
5x5
13 17 21 25
(9 + (5-1)), +4, +4, +4
total diag elems = 5 + 4
7x7
31 37 43 49
(25 + (7-1)), +6, +6, +6
total diag elems = 5 + (4*2)
'''
d = 3
num_diags = [1, 3, 5, 7, 9]
last_num = num_diags[-1]
num_diags_count = len(num_diags)
primes = [n for n in num_diags if is_prime(n)]
primes_count = len(primes)
# float decimal problem
# pct = 100 * primes_count / num_diags_count
# while pct >= thres:
while True:
d += 2
step = d - 1
new_diag_num_first = last_num + step
num_diags_new = [new_diag_num_first,
new_diag_num_first + step,
new_diag_num_first + 2*step,
new_diag_num_first + 3*step]
last_num = num_diags_new[-1]
new_primes = [n for n in num_diags_new if is_prime(n)]
# new_primes_count = len(new_primes)
primes_count += len(new_primes)
num_diags_count += 4
# pct = 100. * primes_count / num_diags_count
if verbose:
# print(f'side length: {d}, diag primes: {pct:.3f}%')
print(f'side length: {d}, {primes_count} primes (out of {num_diags_count})')
# if pct < 10.0:
# if int(str(pct).split('.')[0]) == 9:
if primes_count * thres < num_diags_count:
return d
def solution(num):
summ = 0
for x in range(2, num):
if is_prime(x):
print(x)
summ += x
return summ
def solution():
# n = 2143
# n_max = 987654321
# for x in range(n, n_max+1, 2):
# if is_prime(x):
# if check_one_to_n(x):
# if is_pandigital(x):
# print(x, 'is pandigital prime')
# break
# x = 987654321
# while True:
# # print('checking', x)
# if check_one_to_n(x):
# print(x, 'is made of 1-n digits, each digit exactly once')
# if is_prime(x):
# print(x, 'is prime')
# if is_pandigital(x):
# print(x, 'is pandigital prime')
# break
# x -= 2
max_panprime = 2143
for n in range(9, 1, -1):
permutes = permute_n_digits(n)
nums = [digitlist_to_num(p) for p in permutes]
for num in nums:
if check_one_to_n(num):
if is_prime(num) and is_pandigital(num):
if num > max_panprime:
max_panprime = num
if max_panprime > 2143:
break
return max_panprime
def get_next_prime(n):
if n % 2 == 0:
candidate = n + 1
else:
candidate = n + 2
while not is_prime(candidate):
candidate += 2
return candidate
def solution(nth):
i = 0
num = 1
while i < nth:
num += 1
if is_prime(num):
# print(num)
i += 1
return num
def solution(n_fam, verbose=False):
len_n = 2
while True:
n_min, n_max = get_min_max(len_n)
possible_n_replaces = range(1, len_n)
# print(n_min, n_max)
primes = []
for n in range(n_min+1, n_max+1):
if is_prime(n):
primes.append(n)
if len(primes) == 0:
len_n += 1
continue
for p in primes:
# p_digitlist = num_to_digitlist(p)
for nr in possible_n_replaces:
poss_nr_idxs = list(combinations(range(len_n), nr))
for nr_idxs in poss_nr_idxs:
if verbose:
print('index/indices to replace:', nr_idxs)
if 0 in nr_idxs:
r_digits = range(1, 10)
else:
r_digits = range(0, 10)
prime_family = []
for r in r_digits:
p_replist = num_to_digitlist(p)
for nr_idx in nr_idxs:
# print(nr_idx, r)
p_replist[nr_idx] = r
p_rep_num = digitlist_to_num(p_replist)
if is_prime(p_rep_num):
prime_family.append(p_rep_num)
if verbose:
print(p, prime_family)
if len(prime_family) == n_fam:
# print(prime_family)
return min(prime_family)
len_n += 1
def solution():
num, nhi = 1489, 9999
while num < nhi:
if is_prime(num):
n1 = num
permutes_n1 = permutes_of_num(n1)
n2, n3 = n1 + 3330, n1 + 6660
if (n2 in permutes_n1) and (n3 in permutes_n1):
if is_prime(n2) and is_prime(n3):
ans = int(''.join(map(str, sorted([n1, n2, n3]))))
return ans
# for n2 in [j for j in permutes_n1 if j != n1]:
# for n3 in [k for k in permutes_n1 if k != n1 and k != n2]:
# if (n2 in permutes_n1) and (n3 in permutes_n1):
# if is_prime(n2) and is_prime(n3):
# ans = int(''.join(map(str, sorted([n1, n2, n3]))))
# return ans
num += 1
return None
def check_circular(n):
if not is_prime(n):
return False
digitlist = num_to_digitlist(n)
len_n = len(digitlist)
if len_n == 1:
return is_prime(n)
digitlist = num_to_digitlist(n)
for r in range(1, len_n):
digitlist_rotated = rotate_list(digitlist, r)
num_rotated = digitlist_to_num(digitlist_rotated)
if is_prime(num_rotated):
continue
else:
return False
return True
def check_truncatable(num):
len_num = len(str(num))
if (len_num < 2) or (not is_prime(num)):
return False
digitlist = num_to_digitlist(num)
trun_left = []
trun_right = []
for i in range(1, len_num):
trun_left.append(digitlist_to_num(digitlist[i:]))
trun_right.append(digitlist_to_num(digitlist[:-i]))
all_truns = set(trun_left + trun_right)
print('all truns:', all_truns)
for n in all_truns:
if not is_prime(n):
return False
return True
def solution():
num = 9 # smallest odd composite number (non-prime numbers)
while True:
if is_prime(num):
num += 2
continue
else:
goldbach_true, a, b = goldbach_check(num)
print(num, goldbach_true, a, b)
if goldbach_true:
num += 2
else:
break
return num
def goldbach_check(num):
'''find whether a, b exist such that num == a + 2 * (b ** 2)'''
a_min = 3 # smallest odd prime
b_min = 1 # smallest num to square
a_max = num - 2 * b_min**2
b_max = int(((num - a_min) / 2)**0.5)
# print(a_min, a_max, b_min, b_max)
a_range = range(a_min, a_max + 1)
b_range = range(b_min, b_max + 1)
for a in a_range:
if is_prime(a):
for b in b_range:
if a + 2 * (b**2) == num:
return True, a, b
return False, None, None
def count_diag_primes(a):
if a.shape[0] != a.shape[1]:
print('not a square array')
return None
d = a.shape[0]
diag_coords1 = [(i,i) for i in range(d)]
diag_coords2 = [(i,d-i-1) for i in range(d)]
diag_coords = set(diag_coords1 + diag_coords2)
# print(diag_coords)
cnt = 0
for (i,j) in diag_coords:
if is_prime(a[i][j]):
cnt += 1
pct = 100 * cnt / len(diag_coords)
return cnt, pct
def solution(a_range, b_range):
max_primes = 0
a_ans, b_ans = 0, 0
prod_ab = a_ans * b_ans
for a in a_range:
for b in b_range:
n = 0
prime_count = 0
while True:
y = quad(n, a, b)
if is_prime(y):
prime_count += 1
n += 1
else:
break
if prime_count > max_primes:
max_primes = prime_count
a_ans, b_ans = a, b
prod_ab = a_ans * b_ans
print(f'a={a_ans}, b={b_ans} produce {max_primes} consecutive primes.')
return prod_ab
def get_sum_primes_under(nmax):
# 2+3, 2+3+5+7, ...
# 3+5+7, 3+5+7+11+13, ...
summ_dict = {}
a = 2
while a < nmax:
count = 1
summ_terms = []
b = get_next_prime(a)
# first sum
s = a + b
# print(s)
while s < nmax:
count += 1
if is_prime(s):
summ_terms.append([s, count])
b = get_next_prime(b)
s += b
summ_dict[a] = summ_terms
a = get_next_prime(a)
return summ_dict
def check_all_prime(nums):
for n in nums:
if not is_prime(n):
return False
return True
def make_spiral(d):
diag_coords1 = [(i,i) for i in range(d)]
diag_coords2 = [(i,d-i-1) for i in range(d)]
diag_coords = set(diag_coords1 + diag_coords2)
nums = range(1, d**2+1)
a = np.zeros(shape=(d, d), dtype=int)
center = int((d-1)/2)
# direction order: ruld
dir_order = list('ruld')
dir_idx = 0
curr_dir = dir_order[dir_idx]
# sniff zeros (available space): if can't go, keep same direction
# example: can't go r, go d... can't go u, go r
# initiate first few steps
i, j = center, center
n_idx = 0
a[i][j] = nums[n_idx]
n_idx += 1
# go right
# check right square
# if is_empty_square(a, i, j, curr_dir):
# i, j = next_loc(curr_dir, i, j)
# else:
# i
i, j = next_loc(curr_dir, i, j)
a[i][j] = nums[n_idx]
n_idx += 1
cnt = 0
# advance direction
while n_idx < len(nums):
if dir_idx == len(dir_order) - 1:
next_dir = dir_order[0]
else:
next_dir = dir_order[dir_idx + 1]
if is_empty_square(a, i, j, next_dir):
# update direction
curr_dir = next_dir
dir_idx = dir_order.index(curr_dir)
# print(dir_idx)
# print('moving', curr_dir)
i, j = next_loc(curr_dir, i, j)
a[i][j] = nums[n_idx]
n_idx += 1
# print(a)
if (i,j) in diag_coords:
if is_prime(a[i][j]):
cnt += 1
pct = 100 * cnt / len(diag_coords)
return a, cnt, pct
