def is_prime(n): if n <= M: return sieves[n] for i in primes: if n % i == 0: return False for i in range(max_prime+2, isqrt(n), 2): if n % i == 0: return False return True
def is_prime(n): if n <= M: return sieves[n] for i in primes: if n % i == 0: return False for i in range(max_prime + 2, isqrt(n), 2): if n % i == 0: return False return True
def is_prime(n): if n < MM: return sieves[n] isqrtn = isqrt(n) for p in primes: if p > isqrtn: break if n % p == 0: return False return True
def is_triangle_word(s): num = sum((ord(c)-ord('A')+1) for c in s) if num in triangle_numbers: return True if num < triangle_numbers[-1]: return False n2 = num*8+1 n = isqrt(n2) return n*n == n2
def is_prime_plus(n): if n % 2 == 0: return n == 2 if n % 3 == 0: return n == 3 if n < M: return sieves[n] isqrtn = isqrt(n) for p in primes: if p > isqrtn: return True if n % p == 0: return False
def test(s): if full_f[s[0]] == 0: return 0 c = full_f[s[-1]] if c in (0, 2, 3, 7, 8): return 0 d = full_f[s[-2]] if c == 5 and d != 2: return 0 if c == 6 and d % 2 == 0: return 0 if d % 2 == 1: return 0 n = reduce(lambda x,y: x*10+y, (full_f[c] for c in s)) return n if isqrt(n)**2 == n else 0
def test(s): if full_f[s[0]] == 0: return 0 c = full_f[s[-1]] if c in (0, 2, 3, 7, 8): return 0 d = full_f[s[-2]] if c == 5 and d != 2: return 0 if c == 6 and d % 2 == 0: return 0 if d % 2 == 1: return 0 n = reduce(lambda x, y: x * 10 + y, (full_f[c] for c in s)) return n if isqrt(n)**2 == n else 0
def pe(n, m): s, t = 0, isqrt(n) cache = [(n // i % m) for i in range(1, n // t + 1)] for i in range(t - 1): k = cache[i] s += k * (k + 1) * (2 * k + 1) // 6 k = cache[t - 1] s -= (t - 1) * k * (k + 1) * (2 * k + 1) // 6 s %= m for i in range(n // t): s += (i + 1) ** 2 * cache[i] return s % m
def pe(n, m): s, t = 0, isqrt(n) cache = [(n // i % m) for i in range(1, n // t + 1)] for i in range(t - 1): k = cache[i] s += k * (k + 1) * (2 * k + 1) // 6 k = cache[t - 1] s -= (t - 1) * k * (k + 1) * (2 * k + 1) // 6 s %= m for i in range(n // t): s += (i + 1)**2 * cache[i] return s % m
def pe(M): s = 0 for m in range(2, isqrt(M / 2)): mm = (M - 1) // (2 * m) m2 = m * m start = 1 if m % 2 == 0 else 2 for n in range(start, min(mm - m + 1, m), 2): if gcd(m, n) != 1: continue n2 = n * n if (m2 + n2) % (m2 - n2 - 2 * m * n) != 0: continue s += mm // (m + n) return s
def solve2(n): u = 1 m = isqrt(n) for f in primes: if f > m: u *= 3 break k = 0 while n % f == 0: n //= f k += 1 u *= (2 * k + 1) if n == 1: break return u
def pe(M): s = 0 for m in range(2, isqrt(M/2)): mm = (M-1) // (2*m) m2 = m * m start = 1 if m % 2 == 0 else 2 for n in range(start, min(mm-m+1, m), 2): if gcd(m, n) != 1: continue n2 = n * n if (m2+n2) % (m2-n2-2*m*n) != 0: continue s += mm // (m+n) return s
def pe10(MAX): marked = [0] * MAX value = 3 s = 2 limit = isqrt(MAX)+1 while value < limit: if marked[value] == 0: s += value for i in range(value*value, MAX, value*2): marked[i] = 1 value += 2 for i in range(limit//2*2+1, MAX, 2): if marked[i] == 0: s += i return s
def solve2(n): u = 1 m = isqrt(n) for f in primes: if f > m: u *= 3 break k = 0 while n % f == 0: n //= f k += 1 u *= 2 * k + 1 if n == 1: break return u
def get_root(n, m): #assert 0 < n < 100 root = [0] * m root[0] = isqrt(n) n -= root[0]**2 if n == 0: return [root[0]] a2 = root[0] * 20 for i in range(1, m): n *= 100 for b in range(n // a2, -1, -1): k = (a2 + b) * b if k < n: n -= k break root[i] = b a2 = 10 * (a2 + 2 * b) return root
def get_root(n, m): #assert 0 < n < 100 root = [0]*m root[0] = isqrt(n) n -= root[0]**2 if n == 0: return [root[0]] a2 = root[0]*20 for i in range(1, m): n *= 100 for b in range(n//a2, -1, -1): k = (a2+b)*b if k < n: n -= k break root[i] = b a2 = 10*(a2+2*b) return root
def pe171(n, m): up = isqrt(n * 81) uplimit = up ** 2 + 1 d = [[[0, 0] for j in range(uplimit)] for i in range(n)] for k in range(10): d[0][k * k] = [1, k] for i in range(1, n): ii = 10 ** i if i < m else 0 for j in range(uplimit): for k in range(10): kk = k * k if j < kk: break p, q = d[i - 1][j - kk] d[i][j][0] += p d[i][j][1] += q + ii * k * p # print [(k, d[n-1][k*k]) for k in range(up+1)] return str(sum(d[n - 1][k * k][1] for k in range(1, up + 1)))[-m:]
def pe171(n, m): up = isqrt(n * 81) uplimit = up**2 + 1 d = [[[0, 0] for j in range(uplimit)] for i in range(n)] for k in range(10): d[0][k * k] = [1, k] for i in range(1, n): ii = 10**i if i < m else 0 for j in range(uplimit): for k in range(10): kk = k * k if j < kk: break p, q = d[i - 1][j - kk] d[i][j][0] += p d[i][j][1] += q + ii * k * p # print [(k, d[n-1][k*k]) for k in range(up+1)] return str(sum(d[n - 1][k * k][1] for k in range(1, up + 1)))[-m:]
def func(n): global primes, sieves, SIZE, PRIME_CNT factors = 1 while n % 2 == 0: factors += 1 n /= 2 if factors >= 2: factors -= 1 isqrtn = isqrt(n) while isqrtn >= PRIME_CNT: SIZE = 10*SIZE primes, sieves = get_primes_by_sieve(SIZE) PRIME_CNT = len(primes) for i in range(1,isqrtn): cnt = 1 p = primes[i] while n % p == 0: cnt += 1 n /= p factors *= cnt if n == 1: break return factors
def func(n): global primes, sieves, SIZE, PRIME_CNT factors = 1 while n % 2 == 0: factors += 1 n /= 2 if factors >= 2: factors -= 1 isqrtn = isqrt(n) while isqrtn >= PRIME_CNT: SIZE = 10 * SIZE primes, sieves = get_primes_by_sieve(SIZE) PRIME_CNT = len(primes) for i in range(1, isqrtn): cnt = 1 p = primes[i] while n % p == 0: cnt += 1 n /= p factors *= cnt if n == 1: break return factors
def pe(M): rad = [0] * M rad[1] = 1 for p in range(2, M): if rad[p] > 0: continue isqrtp = isqrt(p) flag = True for q in range(2, isqrtp + 1): if p % q != 0: continue pp = p while pp % q == 0: pp //= q qq = q * rad[pp] pp = p while pp < M: rad[pp] = qq pp *= q flag = (q > isqrtp) break if flag: pp = p while pp < M: rad[pp] = p pp *= p s = 0 for c in range(3, M): cc = (c - 1) // rad[c] if rad[c - 1] <= cc: s += c if cc < 6: continue if c % 2 == 0 and cc < 15: continue if c % 3 == 0 and cc < 10: continue for a in range(2, c // 2): b = c - a if rad[a] > cc or rad[b] > cc: continue if rad[a] * rad[b] <= cc and gcd(a, b) == 1: s += c return s
#840 from time import time t = time() from mathplus import isqrt, gcd M = 1000 p = [0] * (M // 2 + 1) q = [0] * (M // 2 + 1) for n in range(1, M // 2 + 1): for k in range(1, n): if n % k != 0: continue m = n // k if q[m] == 0: for i in range(isqrt(m // 2) + 1, isqrt(m) + 1): if m % i != 0: continue u, v = i, m // i - i if (u + v) % 2 != 0 and gcd(u, v) == 1: q[m] += 1 #if n == 60: #print k, u, v, k*(u*u-v*v), 2*k*u*v, k*(u*u+v*v) p[n] += q[m] print(max((x, i) for i, x in enumerate(p))[1] * 2) #, time()-t ''' from time import time; t=time() from mathplus import isqrt, gcd M = 1000
from time import time t = time() from mathplus import isqrt M = 100 def get_root(n, m): #assert 0 < n < 100 root = [0] * m root[0] = isqrt(n) n -= root[0]**2 if n == 0: return [root[0]] a2 = root[0] * 20 for i in range(1, m): n *= 100 for b in range(n // a2, -1, -1): k = (a2 + b) * b if k < n: n -= k break root[i] = b a2 = 10 * (a2 + 2 * b) return root print(sum(sum(get_root(n, 100)) for n in range(M) if n != isqrt(n)**2)) #, time()-t
#!/usr/bin/python # -*- coding: utf-8 -*- #The smallest number expressible as the sum of a prime square, prime cube, and prime fourth power is 28. In fact, there are exactly four numbers below fifty that can be expressed in such a way: #28 = 22 + 23 + 24 #33 = 32 + 23 + 24 #49 = 52 + 23 + 24 #47 = 22 + 33 + 24 #How many numbers below fifty million can be expressed as the sum of a prime square, prime cube, and prime fourth power? #Answer: #1097343 from time import time; t=time() from mathplus import get_primes_by_sieve, isqrt, pow M = 50000000 sqrtM = isqrt(M) primes, _ = get_primes_by_sieve(sqrtM) p2 = [p*p for p in primes] p3 = [p**3 for p in primes[:int(pow(M, 1.0/3))]] p4 = [p**4 for p in primes[:isqrt(sqrtM)+1]] pool = set(p+q for p in p3 for q in p4 if p+q < M) pool = set(p+q for p in pool for q in p2 if p+q < M) print(len(pool))#, time()-t
from time import time t = time() from mathplus import isqrt, reduce, op M = 12000 n = M D = [2 * i for i in range(n + 1)] def mul(l): return reduce(op.mul, l, 1) p = [[i] for i in range(2, isqrt(2 * n) + 1)] while p: q = [] for l in p: m, s = mul(l), sum(l) - len(l) r = l[-1] mr = m * r while mr <= 2 * n: nn = mr - s - r + 1 if nn > n: break q.append(l + [r]) D[nn] = min(D[nn], mr) r += 1 mr += m p = q
# -*- coding: utf-8 -*- #Triangle, pentagonal, and hexagonal numbers are generated by the following formulae: #Triangle Tn=n(n+1)/2 1, 3, 6, 10, 15, ... #Pentagonal Pn=n(3n−1)/2 1, 5, 12, 22, 35, ... #Hexagonal Hn=n(2n−1) 1, 6, 15, 28, 45, ... #It can be verified that T285 = P165 = H143 = 40755. #Find the next triangle number that is also pentagonal and hexagonal. #Answer: #1533776805 from time import time t = time() from mathplus import isqrt n = 143 while True: n += 1 hn = n * (2 * n - 1) vpn = hn * 6 vn = isqrt(vpn) + 1 if vn % 3 == 0 and vn * (vn - 1) == vpn: print(hn) #, time()-t break # http://mathworld.wolfram.com/HexagonalPentagonalNumber.html
#9 3 7 48073 #For d = 0 to 9, the sum of all S(4, d) is 273700. #Find the sum of all S(10, d). #Answer: #612407567715 from time import time t = time() from mathplus import get_primes_by_sieve, isqrt, product, permutations M = 10 EM = 10**(M - 1) MM = isqrt(10**M) primes, sieves = get_primes_by_sieve(MM) def is_prime(n): if n < MM: return sieves[n] isqrtn = isqrt(n) for p in primes: if p > isqrtn: break if n % p == 0: return False return True def gen(l, m, i): others = list(range(10))
def pe233(): # Unreadable... = =||| #FML primes, _ = get_primes_by_sieve(N // (5**3 * 13**2) + 1, odd_only=True) p4k1 = [] p4k3 = [] for p in primes: if p % 4 == 1: p4k1.append(p) else: p4k3.append(p) len_c = N // (5**3 * 13**2 * 17) + 1 choices = [False] * len_c choices[1] = True for p in p4k3: if p >= len_c: break choices[p] = True for i in range(3, len_c, 2): if choices[i]: continue l = isqrt(i) for p in primes: if p > l: break if i % p == 0: if p % 4 == 3: choices[i] = choices[i // p] break for i in range(1, (len_c + 1) // 2): choices[i * 2] = choices[i] cs = [0] * len_c ss = 0 for i, f in enumerate(choices): if f: ss += i cs[i] = ss s = 0 Ndd = N // (5 * 5 * 13) Nd5 = N // 5 for p1 in p4k1: k = p1**3 if k > Ndd: break for p2 in p4k1: if p2 == p1: continue k2 = k * p2**2 if k2 > Nd5: break for p3 in p4k1: if p3 == p1 or p3 == p2: continue k3 = k2 * p3 if k3 > N: break s += k3 * cs[N // k3] for p1 in p4k1: k = p1**7 if k > Nd5: break for p2 in p4k1: if p2 == p1: continue k2 = k * p2**3 if k2 > N: break s += k2 * cs[N // k2] for p1 in p4k1: k = p1**10 if k > Nd5: break for p2 in p4k1: if p2 == p1: continue k2 = k * p2**2 if k2 > N: break s += k2 * cs[N // k2] return s
def is_pentagonal(n): n2 = n * 24 + 1 n = isqrt(n2) return n * n == n2 and (n + 1) % 6 == 0
#120 cm: (30,40,50), (20,48,52), (24,45,51) #Given that L is the length of the wire, for how many values of L ≤ 1,500,000 can exactly one integer sided right angle triangle be formed? #Note: This problem has been changed recently, please check that you are using the right parameters. #Answer: #161667 from time import time; t=time() from mathplus import gcd, isqrt M = 1500000 q = [0]*(M+1) for m in range(2, isqrt(M/2)+1): for n in range(m % 2 + 1, min(m, M//(2*m)-m+1), 2): #length = 2*m*(m+n) #if length > M: break #x = m*m-n*n #y = 2*m*n #if gcd(x,y)==1: if gcd(m, n)==1: length = 2*m*(m+n) q[length] += 1 p = [0]*(M+1) for m, c in enumerate(q): if c: for n in range(m, M+1, m): p[n] += c
M = 2000000 def tria(n): return n * (n + 1) def is_tria(n): n4 = n * 8 + 1 return isqrt(n4)**2 == n4 #n*(n+1)*m*(m+1) = M*4 cnt = 0 while True: cnt += 1 for k in (M - cnt, M + cnt): sn = 0 n = 1 while True: sn += n n += 1 if sn > k: break if k % sn != 0 or not is_tria(k // sn): continue m = (isqrt(k / sn * 8 + 1) - 1) // 2 print((n - 1) * m) #, time()-t, n-1, m import sys sys.exit()
def is_tria(n): n4 = n * 8 + 1 return isqrt(n4)**2 == n4
def test(u, v): w = u * u + v * v return w == isqrt(w)**2
#It was proposed by Christian Goldbach that every odd composite number can be written as the sum of a prime and twice a square. #9 = 7 + 2×12 #15 = 7 + 2×22 #21 = 3 + 2×32 #25 = 7 + 2×32 #27 = 19 + 2×22 #33 = 31 + 2×12 #It turns out that the conjecture was false. #What is the smallest odd composite that cannot be written as the sum of a prime and twice a square? #Answer: #5777 from time import time t = time() from mathplus import sieve, isqrt M = 10000 p = sieve(M) for n in range(35, M, 2): if p[n]: continue for i in range(1, isqrt((n - 3) / 2) + 1): if p[n - 2 * i * i]: break else: print(n) #, time()-t break
#!/usr/bin/python # -*- coding: utf-8 -*- #There are some prime values, p, for which there exists a positive integer, n, such that the expression n3 + n2p is a perfect cube. #For example, when p = 19, 83 + 82×19 = 123. #What is perhaps most surprising is that for each prime with this property the value of n is unique, and there are only four such primes below one-hundred. #How many primes below one million have this remarkable property? #Answer: #173 #https://github.com/skydark/project-euler/blob/master/131.py from time import time; t=time() from mathplus import isqrt, get_primes_by_sieve M = 10**6 primes, sieves = get_primes_by_sieve(M) m = isqrt(M/3.) ps = set(3*x*x+3*x+1 for x in range(m)) print(len(ps.intersection(primes)))#, time()-t
#There are ten composites below thirty containing precisely two, not necessarily distinct, prime factors: 4, 6, 9, 10, 14, 15, 21, 22, 25, 26. #How many composite integers, n < 108, have precisely two, not necessarily distinct, prime factors? #Answer: #17427258 from time import time t = time() from mathplus import isqrt, get_primes_by_sieve from gen_primes import get_primes #M = 30 M = 10**8 sqrtM = isqrt(M) primes = get_primes(M // 2, odd_only=False) #print time()-t sieves = [0] * (sqrtM + 1) pnext = 2 pnext_index = 0 p = 0 for i in range(sqrtM + 1): if i == pnext: pnext_index += 1 pnext = primes[pnext_index] p += 1 sieves[i] = p #print time()-t ss = sieves[sqrtM] s = ss * (ss + 1) // 2
#!/usr/bin/python # -*- coding: utf-8 -*- #Find the number of integers 1 < n < 107, for which n and n + 1 have the same number of positive divisors. For example, 14 has the positive divisors 1, 2, 7, 14 while 15 has 1, 3, 5, 15. #Answer: #986262 from time import time; t=time() from mathplus import isqrt M=10**7 sieves = [2]*M sieves[0] = 0 sieves[1] = 1 for n in range(2, isqrt(M)): nn = n*n for m in range(nn, M, n): sieves[m] += 2 sieves[nn] -= 1 s = sum(1 for n in range(3, M) if sieves[n] == sieves[n-1]) print(s)#, time()-t
#Let N(n) be the number of t ≤ 1000000 such that t is type L(n); for example, N(15) = 832. #What is ∑ N(n) for 1 ≤ n ≤ 10? #Answer: #209566 from time import time t = time() from mathplus import isqrt M = 1000000 N = range(1, 11) #(15,)# M //= 4 facts = [1] * (M + 1) facts[0] = 0 for i in range(1, isqrt(M + 1)): facts[i * i] -= 1 for i in range(1, M + 1): for j in range(i, M + 1, i): facts[j] += 1 facts[i] //= 2 s = [0] * len(N) for i, n in enumerate(N): s[i] = facts.count(n) print(sum(s)) #, time()-t