def problem_35(): l_primes = numpy_sieve(10**6) l_primes2 = [] for i in l_primes[4:]: a = True for j in nb_to_digits(i): if j % 2 == 0: a = False break if a: l_primes2.append(i) nb = 4 # 2, 3, 5, 7 l_primes3 = [] for i in l_primes2: L = nb_to_digits(i) if digits_to_nb(L[1:] + L[0:1]) in l_primes2: if len(L) == 2: nb += 1 else: l_primes3.append(i) n = len(l_primes3) m = n - 1 while m < n: l_primes4 = [] for i in l_primes3: L = nb_to_digits(i) if digits_to_nb(L[1:] + L[0:1]) in l_primes3: l_primes4.append(i) l_primes3 = l_primes4 n, m = m, len(l_primes3) print(n + nb)
def problem_49(): l4 = numpy_sieve(10**4) i0 = binary_search_inf(l4, 1000) l4 = l4[i0 + 1:] def permut_ok(n): m2 = str(n) m = list(m2) m.sort() for i in range(1, 3): n2 = n + i * 3330 if not binary_search(l4, n2)[0]: return False, "" n2 = str(n2) nn2 = list(n2) nn2.sort() if nn2 != m: return False, "" m2 += n2 return True, m2 for p in l4: if p != 1487: ok, s = permut_ok(p) if ok: print(s) # sol = 296962999629 break
def problem_41(): l_8 = numpy_sieve(10**7) for p in permutations(list("7654321")): p = int("".join(p)) if p in l_8: print(p) # sol = 7652413 break
def problem_50(lim=10**6): L_6 = numpy_sieve(lim) i_end = len(L_6) s_M = 0 nb_M = 1 s = 0 i, j = 0, 0 nb = 0 while j < i_end: while s < lim: s += L_6[j] j += 1 nb += 1 if s in L_6: if nb > nb_M: s_M = s nb_M = nb nb = nb_M - 1 s = sum(L_6[i + 1:i + nb_M]) j = i + nb_M if s + L_6[j] > lim: break i += 1 print(s_M) # sol = 997651
def problem_37(): l_6 = numpy_sieve(1000000) l0 = [2, 3, 5, 7] l2 = [] for k in range(5): l3 = [] for i in [1, 3, 5, 7, 9]: for p in l0: a = p * 10 + i if a in l_6: l3.append(a) l2.extend(l3[:]) l0 = l3 l0 = [2, 3, 5, 7] l4 = [] for k in range(5): l3 = [] for i in [1, 2, 3, 5, 7, 9]: for p in l0: a = p + i * 10**(k + 1) if a in l_6: l3.append(a) l4.extend(l3[:]) l0 = l3 s = 0 nb = 0 for p in l2: if p in l4: s += p nb += 1 if nb == 11: break print(s) # sol = 748317
def problem_46(): l_10000 = numpy_sieve(10000)[1:] ll = set(i for i in range(7, 10**4, 2)) for n in range(70): for p in l_10000: a = p + 2 * n**2 if a > 10000: break if a in ll: ll.remove(a) print(min(ll)) # sol = 5777
def problem_27(): primes = numpy_sieve(10 ** 4) def f(p): return lambda m: m ** 2 - (2 * p - 1) * m + p ** 2 - p + 41 maxi, pm = 0, -1 for q in range(-30, 32): phi = f(q) n = 0 while binary_search(primes, phi(n))[0]: n += 1 if n > maxi: maxi = n pm = q return (1 - 2 * pm) * (pm ** 2 - pm + 41)
def problem_51(): l_7 = numpy_sieve(10**7) i_start = binary_search_inf(l_7, 10**5) def make_pattern(n): m = str(n) for digit in m: if m.count(digit) == 3: yield [ 5 - i for i in range(len(m) - 1, -1, -1) if m[i] == digit ] def apply_pattern(n, pat): n2 = 0 k = 0 while n != 0: n2 += (n % 10) * 10**k if k not in pat else 0 n //= 10 k += 1 return n2 def add(n, pat): for i in pat: n += 10**i return n viewed = set() for p in l_7[i_start:]: for pattern in make_pattern(p): p2 = apply_pattern(p, pattern) if p2 in viewed: continue viewed.add(p2) nb = 0 for d in range(10): if (5 not in pattern or d != 0) and binary_search(l_7, p2)[0]: nb += 1 if nb + 9 - d < 8: break p2 = add(p2, pattern) if nb < 8: continue print(p) # sol = 121313 return
def problem_58(): l_6 = numpy_sieve(10**6) nb, i = 0, 0 a = 1 while True: i += 1 ii = i << 1 a += ii << 2 b = a - ii c = b - ii d = c - ii for j in [b, c, d]: if is_prime(j, l_6): nb += 1 if nb * 10 <= (ii << 1): print(ii + 1) # sol = 26241 break
def problem_12(): primes = numpy_sieve(100) def nb_div(n): l2 = decompose_tout(n, primes) a = 1 for c in l2: a *= c[1] + 1 return a i = 101 nd1 = nb_div(100 / 2) nd2 = nb_div(101) while nd1 * nd2 < 500: i += 1 nd1 = nd2 j = i // 2 if i % 2 == 0 else i nd2 = nb_div(j) return (i * (i - 1)) // 2
def p135(): """ x = y + r, y, z = y - r => (4r-y)*y = n """ l_p = numpy_sieve(10**6) def nb_ok(n): l = decompose_tout(n, l_p) n_l = len(l) l2 = [] nb_div = 0 for i in range(n_l): l2.append(list(range(l[i][1] + 1))) for c in product(*l2): a = 1 for i in range(n_l): a *= l[i][0]**c[i] if 3 * a**2 - n > 0: nb_div += 1 return nb_div l = [] nb = 0 for n in range(1155, 10**6): if n % 4 == 3 and nb_ok(n) == 10: nb += 1 l.append(n) if n % 4 == 0: if n % 8 != 0: if nb_ok(n // 4) == 10: nb += 1 l.append(n) elif n % 16 == 0: if nb_ok(n // 16) == 10: l.append(n) nb += 1 print(nb)
def problem_500(exp_div=500500): l7 = numpy_sieve(10**7) modulo = 500500507 # n_max = 13*38500039 li = [1] lk = [-1, 0] for _ in range(2, exp_div + 1): mini = log(l7[len(li)]) i_min = len(li) for k in lk: p = log(l7[k]) * 2**li[k] if p < mini: i_min = k if i_min == len(li): li.append(1) if lk[1] == -1: lk[1] = len(li) - 1 else: li[i_min] += 1 if i_min == len(li) - 1: lk[li[i_min] - 1] = -1 elif li[i_min + 1] == li[i_min] - 1: lk[li[i_min] - 1] = i_min + 1 else: lk[li[i_min] - 1] = -1 if i_min == 0: lk.append(0) elif li[i_min - 1] == li[i_min]: pass else: lk[li[i_min]] = i_min # if _ == 4: # print(Li, Lk) prod = 1 for i in range(len(li)): prod *= quick_expo(l7[i], 2**li[i] - 1, modulo) prod %= modulo print(prod)
def problem_47(): ll = numpy_sieve(10**3) l0 = [0] * 10**6 for p in ll: for i in range(2 * p, len(l0), p): l0[i] += 1 i = 0 while i + 3 < len(l0): if l0[i] != 4: i += 1 continue else: end = False for j in range(1, 4): if l0[i + j] != 4: i += j + 1 end = True break if end: continue print(i) break # sol = 134043
from Tools import decompose_tout, numpy_sieve, bezout n_fin = 20000 modulo = 1000000007 lp = numpy_sieve(n_fin) def inv(a, p): return bezout(a, p)[1] % p l_inv = {p: inv(int(p) - 1, modulo) for p in lp if p > 2} def sigma(d): a = 1 for p in d: if p == 2: a *= pow(2, d[2] + 1, modulo) - 1 else: a *= (pow(int(p), d[p] + 1, modulo) - 1) * l_inv[p] a %= modulo return a def decompose_B(n, d, df): ln = decompose_tout(n, lp) for p, a in ln: if p in d: d[p] += a * n else:
# %% Problem 268 from Tools import numpy_sieve l = numpy_sieve(100) def f(N=10**16, p=1, k=-1, n=1, a=-1, s=0): tetra = [(i * (i + 1) * (i + 2)) // 6 for i in range(1, 25) ] # see inclusion-exclusion principle & tetrahedral numbers if p > N or n > 25: return s for k2 in range(k + 1, 25): p2 = p * l[k2] if p2 > N: break if n >= 4: s += (N // p2) * a * tetra[n - 4] s = f(N, p2, k2, n + 1, a * -1, s) return s print(f(10**3)) print(f(10**16)) # sol = 785478606870985
# %% Problem 501 # if n has 8 divisors n is equal to p^7 or p^3*q^1 or p*q*r where p, q, r are primes from Tools import numpy_sieve, binary_search_inf l_p = numpy_sieve(3 * 10**4) def nb1(lim): # n = p^7 with n <= lim a = int(lim**(1 / 7)) if (a + 1)**7 < lim: a += 1 if a < 2: return 0 return binary_search_inf(l_p, a) + 1 def nb2(lim): # n = p^3*q with n <= lim s = 0 for i in range(len(l_p)): # q < p p = l_p[i] if p**3 > lim // 2: break s += min(binary_search_inf(l_p[:i + 1], lim / (p**3)) + 1, i) for i in range(len(l_p)): # q > p q = l_p[i] b = lim / q if b < 8: break s += min(binary_search_inf(l_p[:i + 1], b**(1 / 3)) + 1, i) return s
# %% Problem 531 from Tools import numpy_sieve, gcd, bezout l_6 = numpy_sieve(1005000) def v_p(n, p): nb = 0 while n % p == 0: n //= p nb += 1 return nb L = [{} for _ in range(5000)] for p in l_6: n1, r1 = int.__divmod__(10**6, p) if r1 != 0: n1 += 1 n2 = (1005000-1) // p for k in range(n1*p, (n2+1)*p, p): L[k-10**6][p] = v_p(k, p) def phi(n): d = L[n-10**6] prod1 = 1 prod2 = 1 for p in d: prod1 *= (p-1) prod2 *= p
# %% Problem 234 from math import ceil from Tools import numpy_sieve lim = 999966663333 lp = numpy_sieve(int(lim**0.5) + 30) s = 0 for i in range(len(lp) - 1): p1 = lp[i] if p1**2 + 1 > lim: break p2 = lp[i + 1] n1max = (p2**2 - 1) // p1 n1min = p1 + 1 s += p1 * ((n1max * (n1max + 1) - n1min * (n1min - 1)) // 2) n2max = p2 - 1 n2min = ceil((p1**2 + 1) / p2) s += p2 * ((n2max * (n2max + 1) - n2min * (n2min - 1)) // 2) n3max = int((p2**2 - 1) / (p1 * p2)) n3min = ceil((p1**2 + 1) / (p1 * p2)) s -= 2 * p1 * p2 * ((n3max * (n3max + 1) - n3min * (n3min - 1)) // 2) p1, p2 = lp[-2:] s -= sum(k for k in range(lim, p2**2) if (k % p1 == 0) ^ (k % p2 == 0)) # surely a lot fof smarter ways print(s) # s = 1259187438574927161
from math import log from Tools import decompose_tout, numpy_sieve l_8 = numpy_sieve(10**8) d = dict() def log_p(n, p): return int(log(n) / log(p) + 0.5) def decompose_p(n, p): k = 0 while n % p == 0: k += 1 n //= p return k def ok(p): L = [] m = 0 i = 0 k0 = log_p(10**8, p) while i < k0: m += p i += decompose_p(m, p) L.append((i, m)) return L
# %% Problem 351 from Tools import numpy_sieve n_tot = 10**8 l8 = numpy_sieve(n_tot) phi = [i for i in range(n_tot + 1)] for p in l8: for k in range(p, n_tot, p): phi[k] *= (p - 1) phi[k] //= p s_tot = 0 for s in range(1, n_tot + 1): s_tot += s - phi[s] print(s_tot) # sol = 11762187201804552
from Tools import numpy_sieve fib = [0, 1] for _ in range(23): fib.append(fib[-1]+fib[-2]) nn = fib[24] lp = list(numpy_sieve(nn+1)) L = [[], [], [2], [0, 3], [4]] for a in range(5, nn+1): ll = [] for i in range(len(lp)): k = lp[i] if k > a//2: break elif k == a//2 and a % 2 == 0: ll.extend([0] * (i - len(ll))) ll.append(k*k % 10**9) else: if len(L[a-k]) > i: ll.extend([0]*(i-len(ll))) ll.append(sum(L[a-k][i:])*k % 10**9) if a in lp: i = lp.index(a) ll.extend([0] * (i - len(ll))) ll.append(a) L.append(ll)
from Tools import numpy_sieve L = numpy_sieve(5000) L2 = numpy_sieve(sum(L)) LL = [0] * (L2[-1] + 1) LL[0] = 1 s = 0 for b in L: for a in range(s, -1, -1): if a + b >= len(LL): continue LL[a + b] += LL[a] LL[a + b] %= 10**16 s += b print(sum(LL[a] for a in L2) % 10**16) # sol = 9275262564250418
from Tools import numpy_sieve N = 10**10 l10 = numpy_sieve(N) def q(p, n): return min(n//p, p) s = 0 for prime in l10: s += q(prime, N) print(N-s) # sol = 2811077773
from Tools import decompose_tout, numpy_sieve l6 = numpy_sieve(10**6) lp = [True for i in range(10**6 + 1)] for p in l6: k = p**2 while k <= 10**6: lp[k] = False k += p**2 lp = [p for p in range(1, 10**6 + 1) if lp[p]] def s_prime(a, n): return n // (a**3) N = 10**18 M = 10**6 def sol(M): s = 0 for a in range(1, M + 1): if a in lp: s += s_prime(a, N) return s print(sol(M))
# %% Problem 357 from time import time from queue import deque from Tools import numpy_sieve l_primes = numpy_sieve(10**8) timer = time() def ok_mieux(p, l_p): for i in l_p: if p // i + i not in d: return False return True i, p, l, n_lim = 1, 2, l_primes, 10**8 s = 1 # 1 works !!!!!! f = deque() f.append((i, p, [1, 2])) while f.__len__() != 0: i, p, l_p = f.popleft() if i == len(l): s += p if ok_mieux(p, l_p) else 0 else: a = l[i] * p if a <= n_lim: f.append((i + 1, p, l_p))
# %% Problem 717 from Tools import numpy_sieve target = 10 ** 7 primes = numpy_sieve(target) def g(p): x = pow(2, (pow(2, p, p - 1) - p) % (p - 1), p) return ((pow(2, p, p ** 2) * x) % p ** 2) // p def sum_g(): s = 0 for p in primes: s += g(p) return s print("Answer: ", sum_g()) # sol = 1603036763131
ll = [fact(n)] for k in range(1, n): ll.append(l[k] * n + l[k - 1]) ll.append(1) l = ll[:] print(fact(16) // sum(l[8:])) # sol = 2269 # %% Problem 123 # if n % 2 == 0: reminder = 2 # else : reminder = 2*n*p_n from Tools import numpy_sieve l = numpy_sieve(10**6) for i, p in enumerate(l[1::2]): if 2 * (2 * i + 3) * p > 10**10: print(2 * i + 3) break # sol = 21035 # %% Problem 124 def rad(n): l = [] while n % 2 == 0: if 2 not in l: l.append(2) n //= 2
k = k_max(p) return ((1 - k) * (p - 1) + p**(k + 2) - p**3) // ((p - 1)**2) s = 0 for p in range(2, p_max + 1): s += sum_p(p) s += 1 s -= 31 + 8191 # sol = 336108797689259276 # %% Problem 347 from math import log from Tools import numpy_sieve l = numpy_sieve(10**7) S = 0 n = len(l) for i in range(n): for j in range(i + 1, n): p = l[i] q = l[j] a1, a2 = 1, int(log(10**7 / p) / log(q)) if a2 != 0: nb_max = p**a1 * q**a2 while a1 < int(log(10**7 / q) / log(p)): a1 += 1 while p**a1 * q**a2 > 10**7 and a2 > 1: a2 -= 1 if p**a1 * q**a2 > nb_max:
# %% Problem 593 from Tools import numpy_sieve l_p = numpy_sieve(10**8) def s(k): return pow(l_p[k - 1], k, 10007) def s2(k): return s(k) + s(k // 10000 + 1) L = [s(i) for i in range(1, 10**5)] L2 = [s2(i) for i in range(1, 10**5)] def m(i, j): LL = sorted(L2[i - 1:j]) n = len(LL) q, r = n.__divmod__(2) if r == 1: return LL[q] else: a = LL[q - 1] + LL[q] r = a % 2 a //= 2 a += (0 if r == 0 else 0.5) return a
elif n % 4 == 3: k = n p = lpd(k) if p == 0 or p == k: return True return ok_aux(p, k) else: return False def number(n): nb = 0 for i in range(n): if ok(i): nb += 1 return nb print("Problem 136: ", number(10**6*50)) # the 'good' n's are n == 4P or 16P or P where P prime and n == 4*1 and n == 16*1 # so : maxi = 10**6*50 l_pp = numpy_sieve(maxi) tot = 0 for a in l_pp: if a % 4 == 3: tot += 1 tot += binary_search_inf(l_pp, maxi//4) + 1 tot += binary_search_inf(l_pp, maxi//16) + 1 print(tot)