def find_consecutive_nums_with_prime_factors(num_numbers, num_factors):
sequence = []
num_check = 2
allfactors = defaultdict(make_defaultdict_int)
allprimes = primes.generate_primes_up_to(1000000)
allfactors.update({p:{p:1} for p in allprimes})
allfactors[1] = {}
while len(sequence) < num_numbers:
num = num_check
factors = defaultdict(int)
while num not in allfactors:
for p in allprimes:
fac = num/p
while int(fac) == fac:
num = int(fac)
factors[p] += 1
fac = num/p
if p > num:
break
add_dicts(factors,allfactors[num])
allfactors[num_check] = factors
if len(factors) >= num_factors:
sequence.append(num_check)
else:
sequence = []
num_check = num_check + 1
return sequence
def longest_sum_subsequence(max_prime):
max_prime_to_try = int(max_prime / 2)
pr_trials = primes.generate_primes_up_to(max_prime_to_try)
pr_sums = list(pr_trials)
pr_set = set(primes.generate_primes_up_to(max_prime))
lcs = 1, 2
i = 1
while len(pr_sums) > 1 and pr_sums[0] < max_prime:
# print('iterating',i,pr_sums)
for L in range(len(pr_sums) - 1):
pr_sums[L] = pr_sums[L] + pr_trials[L + i]
cutoff = -1
for S in pr_sums[::-1]:
if S > max_prime:
cutoff = cutoff - 1
if S in pr_set:
lcs = i, S
pr_sums = pr_sums[:cutoff]
i = i + 1
return lcs
def longest_prime_sequence(bounds_a, bounds_b, allprimes): """Returns the pair of numbers that generate the longest sequence of primes using prime_sequence. bounds_a and bounds_b are both (int,int) tuples of inclusive min/max format, to bound a and b. longest_prime_sequence(tuple, tuple, list) -> int,int,int """ #b has to be a positive odd prime #a has to be odd #a+b+1 has to be prime #|b| has to be > |a| import math longest,long_a,long_b = 0,0,2 # make bounds of 'a' odd min_a,max_a = (bounds_a[0] >> 1) + 1, (bounds_a[1] >> 1) + 1 for a in range(min_a, max_a, 2): for b in range(int(math.fabs(a)),bounds_b[1],2): primes.generate_primes_up_to(b, allprimes) if b in allprimes: seq = prime_sequence(a,b) if seq > longest: long_a,long_b,longest = a,b,seq return long_a,long_b,longest
def prime_sequence(a,b,allprimes=[2,3]): """Returns the number of consecutive primes generated from n^2 + an + b for n >= 0. prime_sequence(int,int[,list]) -> int """ import math import primes seq = 0 for i in range(b): test = math.pow(i,2) + a * i + b if test in primes.generate_primes_up_to(test, allprimes): seq += 1 else: break return seq
def find_circular_primes(max_val): circular_primes = set() allprimes = set([p for p in primes.generate_primes_up_to(max_val, [2,3])]) for p in allprimes: if p not in circular_primes: is_circular = True circs = set((p,)) for sh in range(1,len(str(p))): c = right_rotate(p, sh) if c in allprimes: circs.add(c) else: is_circular = False break if is_circular: circular_primes = circular_primes.union(circs) return circular_primes
def factorize(n, pr=None):
"""Return a set of factors of n.
factorize(int[, list]) -> set
pr is an optional sorted list of primes up to sqrt(n), and will be generated if it is not given"""
if pr == None:
pr = generate_primes_up_to(int(sqrt(n)))
orig = n
facs = set()
while n > 1:
added = False
for p in pr:
if n % p == 0:
newfacs = set(x * p for x in facs)
n = int(n/p)
facs = facs.union(newfacs)
facs.add(p)
added = True
break
if not added:
facs.add(n)
break
return facs.union({1,orig})
def key_permutations(n):
s = str(n)
keys = set()
for digit in '0123456789':
c = s.count(digit)
if c > 0:
hits = [i for i in range(len(s)) if s[i] == digit]
for i in range(1,len(hits)+1):
for p in itertools.permutations(hits, i):
#I can do this next step because I know that there's 8 numbers, so the number of digits replaced has to be a multiple of 3
if len(p) % 3 != 0:
break
key = s
for t in p:
key = key[:t] + '*' + key[t+1:]
keys.add(key)
return keys
pr = primes.generate_primes_up_to(1000000)
replacemap = defaultdict(list)
answers = []
for p in pr:
for k in key_permutations(p):
replacemap[k].append(p)
if len(replacemap[k]) >= 8:
answers.append(replacemap[k])
ans = min([min(k) for k in answers if len(str(min(k))) == len(str(max(k)))])
