def find_prime_family(size, lower_bound, upper_bound): families = {} primes = sorted(list(primes_up_to(upper_bound))) for p in primes: if p < lower_bound: continue digits = str(p) num_digits = len(digits) for to_replace in range(1, num_digits - 1): possible_replacements = combinations(range(num_digits), to_replace) for replacements in possible_replacements: replacements = list(replacements) digit_list = list(digits) if all(digit_list[r] == digit_list[replacements[0]] for r in replacements): for r in replacements: digit_list[r] = '*' replaced_digits = ''.join(digit_list) families.setdefault(replaced_digits, []) families[replaced_digits].append(digits) if len(families[replaced_digits]) >= size: return families[replaced_digits]
def find_goldbach_counter(upper_bound): primes = primes_up_to(upper_bound) for n in range(9, upper_bound, 2): if n in primes: continue if not satisfies_goldbach(n, primes): return n
def count_circular_primes(n): circular_primes = [] primes = primes_up_to(n) for prime in primes: if is_circular_prime(prime, primes): circular_primes.append(prime) return len(circular_primes)
def find_truncatable_primes(): truncatable_primes = set([]) n = 100 while (True): primes = primes_up_to(n) for p in primes: if is_truncatable_prime(p, primes): truncatable_primes.add(p) if len(truncatable_primes) == 11: return truncatable_primes n *= 10
def find_permutated_prime(lower_bound, upper_bound, required_perms): primes = primes_up_to(upper_bound) results = [] for p in primes: if p < lower_bound: continue perms = filter(lambda perm: perm > p and perm in primes, permutate_number(p)) for i in range(len(perms)): for j in range(i + 1, len(perms)): if 2 * (perms[i] - p) == perms[j] - p: results.append((p, perms[i], perms[j])) return results
def find_largest_pandigital_prime(n_digits): primes = primes_up_to(10**n_digits) digits = [str(d) for d in range(1, n_digits + 1)] while(digits): max_found = 0 for arrangement in permutations(digits): n = int(''.join(arrangement)) if n in primes: max_found = max(n, max_found) if max_found: return max_found digits.pop()
def find_prime_ratio(required_ratio, upper_bound): s = 1 prime_count = 0 primes = primes_up_to(upper_bound) for diagonals in get_diagonals(): for d in diagonals: if d > upper_bound: if is_prime(d, cache_result=False): prime_count += 1 elif d in primes: prime_count += 1 ratio = (prime_count / float(s * 4)) if ratio < required_ratio: return (2 * s) + 1 s += 1
def find_consecutive_prime_sum(upper_bound): primes = primes_up_to(upper_bound) sorted_primes = sorted(list(primes)) longest_sequence = [] for i in range(len(sorted_primes)): sequence = [] k = 0 while (True): if i + k >= len(sorted_primes): break sequence.append(sorted_primes[i + k]) if sum(sequence) > upper_bound: break if sum(sequence) in primes: if len(sequence) > len(longest_sequence): longest_sequence = copy(sequence) k += 1 return longest_sequence
while (True): p = n - (2 * s**2) if p < 2: return False if p in primes: return True s += 1 def find_goldbach_counter(upper_bound): primes = primes_up_to(upper_bound) for n in range(9, upper_bound, 2): if n in primes: continue if not satisfies_goldbach(n, primes): return n primes = primes_up_to(50) test(satisfies_goldbach(9, primes), True) test(satisfies_goldbach(27, primes), True) test(satisfies_goldbach(33, primes), True) print find_goldbach_counter(10000)
if not int(remaining_digits) in primes: return False return True def find_truncatable_primes(): truncatable_primes = set([]) n = 100 while (True): primes = primes_up_to(n) for p in primes: if is_truncatable_prime(p, primes): truncatable_primes.add(p) if len(truncatable_primes) == 11: return truncatable_primes n *= 10 primes = primes_up_to(10000) test(is_truncatable_prime(3797, primes), True) test(is_truncatable_prime(37, primes), True) test(is_truncatable_prime(2, primes), False) test(is_truncatable_prime(43, primes), False) print sum(find_truncatable_primes())
from helpers import primes_up_to print sum(primes_up_to(2000000))
from math import floor, log from helpers import divisors, primes_up_to k = 20 p = primes_up_to(k) a = [floor(log(k) / log(p_i)) for p_i in p] print int(reduce(lambda x, y: x * y, [p_i**a_i for (p_i, a_i) in zip(p, a)]))