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