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