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)]))
