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