# find the 12-digit number formed by concatenating a series of 3 4-digit # numbers who are permutations of each other and are all prime from itertools import permutations, dropwhile from pe_utils import prime_sieve prime_set = set(prime_sieve(10000)) def perm(n, inc): perm_set = set(map(lambda x: int("".join(x)), permutations(str(n)))) perms = (n, n + inc, n + inc*2) if any(map(lambda x: x not in prime_set or x not in perm_set, perms)): return None else: return perms primes = dropwhile(lambda x: x < 1000, prime_sieve(3333)) primes = filter(lambda x: x != None, map(lambda x: perm(x, 3330), primes)) primes = list(map(lambda x: x[0] * 10**8 + x[1] * 10**4 + x[2], primes)) print(primes)
# Find the prime generating polynomial of form n^2 + an + b # where |a| < 1000 & |b| < 1000 and generates the longest array of primes from pe_utils import prime_sieve, discriminant_bc, complex_quad_polys, primes_to_n primes = list(prime_sieve(10000)) # only quadratics with disriminant less than 0 can be prime generating # |b| <= 63 # c cannot be negative, otherwise discriminant would be positive # 1 <= c <= 1000 # |c| must be prime (1st iteration is always c, and since we're finding primes, c must always be prime) poly_gen = complex_quad_polys(range(-63, 63 + 1), list(primes_to_n(1000))) def polynomial(a, b, i): return i * i + a * i + b highest_num_primes = 0 high_ab = None for ab in poly_gen: iterations = 0 while polynomial(ab[0], ab[1], iterations) in primes: iterations += 1 if iterations > highest_num_primes: high_ab = ab highest_num_primes = iterations print(high_ab, highest_num_primes)
# find the first four consecutive integers # with unique prime factors from pe_utils import prime_sieve, factor_map from itertools import count, repeat, takewhile distinct_factors = 4 prime_gen = prime_sieve() primes = [next(prime_gen)] factor_dict = {} def n_distinct_factors(n): global factor_dict, primes, prime_gen if n in factor_dict: return factor_dict[n] else: if n in primes: return 1 while primes[-1] < n: primes.append(next(prime_gen)) distincts = len(list(factor_map(n, takewhile(lambda x: x < n, primes), True))) factor_dict[n] = distincts return distincts for i in count(1): consec_nums = map(lambda x: x[0] + x[1], enumerate(repeat(i, distinct_factors))) consec_facs = map(lambda x: n_distinct_factors(x) == distinct_factors, consec_nums) if all(consec_facs):
# find the greatest prime under 1000000 that is the sum of consecutive primes from pe_utils import prime_sieve from itertools import takewhile max_sum = 1000000 primes = list(prime_sieve(max_sum)) num_primes = len(primes) sums = list(takewhile(lambda x: x < max_sum, (sum(primes[:x]) for x in range(num_primes)))) num_sums = len(sums) max_len = 0 def sum_and_bump(i, j): global max_len max_len = j - i return sums[j] - sums[i] print(max([sum_and_bump(i, j) for i in range(num_sums) for j in range(i + 1 + max_len, num_sums) if j - i > max_len])) # 997661 # 0.37 ms # 2.40 GHz CPU
# find the greatest prime under 1000000 that is the sum of consecutive primes from pe_utils import prime_sieve from itertools import takewhile max_sum = 1000000 primes = list(prime_sieve(max_sum)) num_primes = len(primes) sums = list( takewhile(lambda x: x < max_sum, (sum(primes[:x]) for x in range(num_primes)))) num_sums = len(sums) max_len = 0 def sum_and_bump(i, j): global max_len max_len = j - i return sums[j] - sums[i] print( max([ sum_and_bump(i, j) for i in range(num_sums) for j in range(i + 1 + max_len, num_sums) if j - i > max_len ])) # 997661 # 0.37 ms
# Find the prime generating polynomial of form n^2 + an + b # where |a| < 1000 & |b| < 1000 and generates the longest array of primes from pe_utils import prime_sieve, discriminant_bc, complex_quad_polys, primes_to_n primes = list(prime_sieve(10000)) # only quadratics with disriminant less than 0 can be prime generating # |b| <= 63 # c cannot be negative, otherwise discriminant would be positive # 1 <= c <= 1000 # |c| must be prime (1st iteration is always c, and since we're finding primes, c must always be prime) poly_gen = complex_quad_polys(range(-63, 63 + 1), list(primes_to_n(1000))) def polynomial(a, b, i): return i*i + a*i + b highest_num_primes = 0 high_ab = None for ab in poly_gen: iterations = 0 while polynomial(ab[0], ab[1], iterations) in primes: iterations += 1 if iterations > highest_num_primes: high_ab = ab highest_num_primes = iterations print(high_ab, highest_num_primes) print(highest_num_primes, high_ab)
# find the first four consecutive integers # with unique prime factors from pe_utils import prime_sieve, factor_map from itertools import count, repeat, takewhile distinct_factors = 4 prime_gen = prime_sieve() primes = [next(prime_gen)] factor_dict = {} def n_distinct_factors(n): global factor_dict, primes, prime_gen if n in factor_dict: return factor_dict[n] else: if n in primes: return 1 while primes[-1] < n: primes.append(next(prime_gen)) distincts = len( list(factor_map(n, takewhile(lambda x: x < n, primes), True))) factor_dict[n] = distincts return distincts for i in count(1): consec_nums = map(lambda x: x[0] + x[1],
# Find the sum of all 11 primes that are truncatable from right to left and left to right from pe_utils import prime_sieve from math import log10 # from itertools import izip truncatables = [] primes = set(list(prime_sieve(1000000))) valid_least_sig = set([3, 7]) valid_most_sig = set([2, 3, 5, 7]) # valid_middle = set([1, 3, 7, 9]) def rtl_gen(n): for i in range(int(log10(n))): n /= 10 yield n def ltr_gen(n): for i in range(int(log10(n)), 0, -1): n %= 10**i yield n for prime in primes: if prime > 7 and prime % 10 in valid_least_sig and prime / 10**(int(log10(prime))) in valid_most_sig: truncatable = True for rtl in rtl_gen(prime): if rtl not in primes: truncatable = False break