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
#What is the sum of all such integers n below 150 million?
#Answer:
#676333270
#https://github.com/skydark/project-euler/blob/master/146.py
from time import time
t = time()
from mathplus import get_primes_by_sieve, chain
M = 150000000 #1000000
PM = M
dp = (1, 3, 7, 9, 13, 27)
ndp = (19, 21)
test = [10, 80, 130, 200]
circle = 210
P, _ = get_primes_by_sieve(PM)
testset = P[
4:
50] #(11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 67, 71, 73, 79, 83, 89, 97)
#print time()-t
def is_prime2(n):
for p in P:
if p > n: break
n2 = (n % p)**2
for d in dp:
if (n2 + d) % p == 0: return False
n2 = n * n
for d in ndp:
nn = n2 + d
#!/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
#41 20 7 8 9 10 27
#42 21 22 23 24 25 26
#43 44 45 46 47 48 49
#It is interesting to note that the odd squares lie along the bottom right diagonal, but what is more interesting is that 8 out of the 13 numbers lying along both diagonals are prime; that is, a ratio of 8/13 62%.
#If one complete new layer is wrapped around the spiral above, a square spiral with side length 9 will be formed. If this process is continued, what is the side length of the square spiral for which the ratio of primes along both diagonals first falls below 10%?
#Answer:
#26241
#from time import time; t=time()
from mathplus import isqrt, sieve, get_primes_by_sieve
M = 23000
primes, sieves = get_primes_by_sieve(M, odd_only=True)
max_prime = primes[-1]
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
a, b = 0, 1
n2 = 1
double_n = 2
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
#Interestingly, φ(87109)=79180, and it can be seen that 87109 is a permutation of 79180.
#Find the value of n, 1 < n < 107, for which φ(n) is a permutation of n and the ratio n/φ(n) produces a minimum.
#Answer:
#8319823
from time import time; t=time()
#import psyco; psyco.full()
#from gen_primes import get_primes
from mathplus import get_primes_by_sieve
M = 10000000
primes, _ = get_primes_by_sieve(M, odd_only=True)
#primes = get_primes(M, odd_only=True)
#print time()-t
phis = list(range(M))
for i in range(2, M, 2):
phis[i] = 0
for p in primes:
if p >= M: break
for i in range(p, M, p):
phis[i] -= phis[i]//p
#print time()-t
def is_permutation(x, y):
sx, sy = str(x), str(y)
return len(sx) == len(sy) and ''.join(sorted(sx)) == ''.join(sorted(sy))
#!/usr/bin/python
# -*- coding: utf-8 -*-
#Let pn be the nth prime: 2, 3, 5, 7, 11, ..., and let r be the remainder when (pn−1)n + (pn+1)n is divided by pn2.
#For example, when n = 3, p3 = 5, and 43 + 63 = 280 ≡ 5 mod 25.
#The least value of n for which the remainder first exceeds 109 is 7037.
#Find the least value of n for which the remainder first exceeds 1010.
#Answer:
#21035
#https://github.com/skydark/project-euler/blob/master/123.py
from time import time
t = time()
from mathplus import get_primes_by_sieve, takewhile
M = 10**10
L = 1000000
p, sieves = get_primes_by_sieve(L)
for n in takewhile(lambda x: 2 * x * p[x - 1] <= M, range(7037, L, 2)):
pass
print(n + 2) #, time()-t
#We can see that 28 is the first triangle number to have over five divisors.
#What is the value of the first triangle number to have over five hundred divisors?
#Answer:
#76576500
from time import time
t = time()
from mathplus import get_primes_by_sieve, isqrt
#from mathplus import factorization, reduce, op
LEAST = 500
SIZE = 100
primes, sieves = get_primes_by_sieve(SIZE)
PRIME_CNT = len(primes)
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)
#We can see that 28 is the first triangle number to have over five divisors.
#What is the value of the first triangle number to have over five hundred divisors?
#Answer:
#76576500
from time import time; t=time()
from mathplus import get_primes_by_sieve, isqrt
#from mathplus import factorization, reduce, op
LEAST = 500
SIZE = 100
primes, sieves = get_primes_by_sieve(SIZE)
PRIME_CNT = len(primes)
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):
#!/usr/bin/python
# -*- coding: utf-8 -*-
#The primes 3, 7, 109, and 673, are quite remarkable. By taking any two primes and concatenating them in any order the result will always be prime. For example, taking 7 and 109, both 7109 and 1097 are prime. The sum of these four primes, 792, represents the lowest sum for a set of four primes with this property.
#Find the lowest sum for a set of five primes for which any two primes concatenate to produce another prime.
#Answer:
#26033
from time import time; t=time()
from mathplus import isqrt, log10, get_primes_by_sieve, dropwhile
L = 10000
primes, sieves = get_primes_by_sieve(L, odd_only=True)
max_prime = primes[-1]
def is_prime(n):
if n <= L: 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 concat(i, j):
return 10**(int(log10(j))+1)*i+j
s = L * 5
checks = {}
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
#If all of the tiles for which PD(n) = 3 are listed in ascending order to form a sequence, the 10th tile would be 271.
#Find the 2000th tile in this sequence.
#Answer:
#14516824220
from time import time; t=time()
from mathplus import get_primes_by_sieve
# 3n(n-1)+2, where 6n-1, 6n+1, 12n+5 in primes
N = 2000
M = 1000000
_, sieves = get_primes_by_sieve(M)
s, r = 1, 0
for n in range(2, (M-5)//12):
if sieves[6*n-7] and sieves[6*n-1] and sieves[12*n-19]:
s += 1
if s == N:
r = 3*n*(n-1)+1
break
if sieves[6*n-1] and sieves[6*n+1] and sieves[12*n+5]:
s += 1
if s == N:
r = 3*n*(n-1)+2
break
print(r)#, time()-t)
#What is the sum of all such integers n below 150 million?
#Answer:
#676333270
from time import time; t=time()
from mathplus import get_primes_by_sieve, chain
M = 150000000#1000000
PM = M
dp = (1, 3, 7, 9, 13, 27)
ndp = (19, 21)
test = [10, 80, 130, 200]
circle = 210
P, _ = get_primes_by_sieve(PM)
testset = P[4:50]#(11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 67, 71, 73, 79, 83, 89, 97)
#print time()-t
def is_prime2(n):
for p in P:
if p > n: break
n2 = (n % p)**2
for d in dp:
if (n2+d) % p == 0: return False
n2 = n*n
for d in ndp:
nn = n2+d
flag = False
for p in chain((3,7), testset, P):
if p > n: break # <FIXME> nn = 10**2+21
#Consider the consecutive primes p1 = 19 and p2 = 23. It can be verified that 1219 is the smallest number such that the last digits are formed by p1 whilst also being divisible by p2.
#In fact, with the exception of p1 = 3 and p2 = 5, for every pair of consecutive primes, p2 > p1, there exist values of n for which the last digits are formed by p1 and n is divisible by p2. Let S be the smallest of these values of n.
#Find ∑ S for every pair of consecutive primes with 5 ≤ p1 ≤ 1000000.
#Answer:
#18613426663617118
#https://github.com/skydark/project-euler/blob/master/134.py
from time import time; t=time()
from mathplus import log10, get_primes_by_sieve
M = 10**6+5
primes, _ = get_primes_by_sieve(M)
def f(n, m):
#assert n > m
if (n, m) == (1, 0): return 1, 0
q, r = n//m, n%m
a, b = f(m, r)
return b, a-b*q
s = 0
for i in range(2, len(primes)-1):
p, q = primes[i:i+2]
n = 10**(int(log10(p))+1)
a, b = f(q, n%q)
s += (b*(q-p) % q)*n+p
#For example, R(10) = 1111111111 = 11×41×271×9091, and the sum of these prime factors is 9414.
#Find the sum of the first forty prime factors of R(109).
#Answer:
#843296
#https://github.com/skydark/project-euler/blob/master/132.py
from time import time; t=time()
from mathplus import pow_mod, get_primes_by_sieve
M = 10**9
C = 40
L = 200000
primes, sieves = get_primes_by_sieve(L)
def f(n, m, p):
# assert p in primes
return pow_mod(n, m % (p-1), p)
s = 0
c = C
for p in primes[3:]:
if f(10, M, p) == 1:
s += p
c -= 1
if c == 0: break
else:
raise Exception('L is too low')
# Find the smallest denominator d, having a resilience R(d) < 15499/94744 .
# Answer:
# 892371480
from time import time
t = time()
from mathplus import get_primes_by_sieve, takewhile
A = 15499
B = 94744
M = 100
primes, sievs = get_primes_by_sieve(M)
def no_primes_larger_than(n, p):
for pp in takewhile(lambda x: x <= p, primes):
while n % pp == 0:
n //= pp
return n == 1
a = 1
b = 1
pool = []
for p in primes:
a *= p - 1
b *= p
