def g_hamming_nums(lim, n): primes = read_primes(n) nums = [] seen = set() def helper(k): if k > lim or k in seen: return nums.append(k) seen.add(k) for i in primes: helper(k * i) helper(1) return nums
from time import perf_counter from lib.prime import read_primes from fractions import Fraction start = perf_counter() primes = set(read_primes(501)) sequence = 'PPPPNNPPPNPPNPN' cache = {} def path(num, den, c, idx): tup = (num, den, c, idx) if tup in cache: return cache[tup] if idx >= len(sequence): return Fraction(num, den) if c in primes: mult = 2 if sequence[idx] == 'P' else 1 else: mult = 1 if sequence[idx] == 'P' else 2 t = 0 if 1 < c < 500: t += path(num * mult, den * 6, c - 1, idx + 1) t += path(num * mult, den * 6, c + 1, idx + 1) elif c == 1: t += path(num * mult, den * 3, c + 1, idx + 1) elif c == 500: t += path(num * mult, den * 3, c - 1, idx + 1)
from lib.utility import start_time, end_time, mod_inverse from lib.prime import read_primes start_time() primes = read_primes(1000030)[2:] def connection(i): p1, p2 = primes[i], primes[i + 1] n = 10**len(str(p1)) # computing a multiplier such that multiplier * p2 == 1 (mod n) multiplier = mod_inverse(p2, n) # modifying the multiplier so that (p1 * multiplier) * p2 == p1 (mod n) multiplier = (p1 * multiplier) % n return multiplier * p2 solution = 0 for i in range(len(primes) - 1): solution += connection(i) print('Solution:', solution) end_time()
from lib.utility import start_time, end_time from lib.prime import read_primes start_time() prime_set = set(read_primes(10 ** 6)) def A(n): k = 1 repunit = 1 while repunit != 0: repunit = (10 * repunit + 1) % n k += 1 return k n = 91 composites = [] while len(composites) < 25: if n % 2 != 0 and n % 5 != 0 and n not in prime_set: if (n - 1) % A(n) == 0: composites.append(n) n += 1 print('Solution:', sum(composites)) end_time()
from lib.utility import start_time, end_time from lib.prime import read_primes from bisect import bisect_left start_time() primes = read_primes(100) # limit = 10 ** 16 import random # limit = random.randint(1000, 10 ** 5) limit = 43268 # limit = 10 ** 16 print('limit=', limit) v1 = set() v2 = set() def version_100_iq(limit): nums = [] for x in range(2, limit): facs = 0 n = x for p in primes: if n % p == 0: facs += 1 while n % p == 0: n //= p if n == 1 or facs >= 4: break
from lib.utility import start_time, end_time, subsets, product from lib.prime import read_primes start_time() primes = read_primes(190) prods1 = [product(p) for p in subsets(primes[:len(primes) // 2])] prods2 = [product(p) for p in subsets(primes[len(primes) // 2:])] prods1.sort() prods2.sort() sqrt = product(primes) ** 0.5 i = 0 j = len(prods2) - 1 best = 0 while i < len(prods1) and j >= 0: current = prods1[i] * prods2[j] if current >= sqrt: best = min(current, best) j -= 1 elif current < sqrt: best = max(current, best) i += 1 print('Solution:', best % (10 ** 16)) end_time()
from lib.utility import start_time, end_time from lib.prime import read_primes start_time() primes = read_primes(10**6) def r(n): p = primes[n - 1] p_sq = p * p x = pow(p - 1, n, p_sq) + pow(p + 1, n, p_sq) return x % p_sq n = 1 goal = 10**10 while r(n) <= goal: n += 1 print('Solution:', n) end_time()
from time import perf_counter import lib.prime as prime start = perf_counter() primes = prime.read_primes(40 * 10 ** 6) prime_set = set(primes) totient = prime.totient_table(40 * 10 ** 6) t_gen = perf_counter() - start print('Done creating totient table.', t_gen, 'seconds') cache = {} def chain(n): if n in cache: return cache[n] elif n == 1: return 1 elif n in prime_set: ans = 1 + chain(n - 1) else: ans = 1 + chain(totient[n]) cache[n] = ans return ans tot = 0 num = 0 for p in primes: if chain(p) == 25: num += 1
from time import perf_counter from lib.prime import read_primes start = perf_counter() primes = read_primes(5 * 10**7) tot = 0 limit = 10**8 for i in range(len(primes)): for j in range(i, len(primes)): if primes[i] * primes[j] >= limit: break tot += 1 print(tot) end = perf_counter() print(end - start, 'seconds to run')
from time import perf_counter import lib.prime as prime start = perf_counter() lim = 10**8 tbl = [None] * lim primes = prime.read_primes(lim)[2:] def extended_euclid(a, b): if b == 0: return (a, 1, 0) d1, s1, t1 = extended_euclid(b, a % b) d = d1 s = t1 t = s1 - (a // b) * t1 return (d, s, t) def mod_inv(a, m): if a == 0: return 0 d, x, y = extended_euclid(a, m) if d != 1: raise Exception('gcd of %d and %d is not 1' % (a, m)) return (x % m + m) % m def S(p): tot = 0 t = p - 1
from lib.utility import start_time, end_time, nCr_tbl from lib.prime import read_primes start_time() limit = 51 primes = read_primes(2 * limit) def squarefree_nCr(n): i = 0 while primes[i] < limit: if n % (primes[i]**2) == 0: return False i += 1 return True nums = sum((nCr_tbl(i) for i in range(limit)), []) ans = sum(set(filter(squarefree_nCr, nums))) print('Solution:', ans) end_time()
from time import perf_counter from lib.prime import read_primes start = perf_counter() N = 10**8 primes = read_primes(N) mod = 1000000009 t = 1 for p in primes: e = c = N // p while c > 0: c //= p e += c t = t * (pow(p, 2 * e, mod) + 1) % mod print('Solution:', t) end = perf_counter() print(end - start, 'seconds to run')
from time import perf_counter import lib.prime as prime from heapq import * start = perf_counter() primes = prime.read_primes(10**7) heap = [2] prod = 1 idx = 1 for i in range(500500): k = heappop(heap) prod = (prod * k) % 500500507 heappush(heap, k * k) heappush(heap, primes[idx]) idx += 1 print('Solution:', prod) end = perf_counter() print(end - start, 'seconds to run')