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)
