def pr070(n):
primes_1 = getPrimes(int(sqrt(n)))
primes_2 = getPrimes(n >> 1)
minValue = 2147483647
minN = 0
for x in primes_1:
for y in primes_2:
if x * y > n:
break
phi = (x - 1) * (y - 1)
if isValid(x*y, phi) and float(x*y)/float(phi) < minValue:
minN = x * y
minValue = float(x*y)/phi
return minN
def pr293(N):
def getPseudo(n):
t = n + 3
while not isPrimeMR(t):
t += 2
return t - n
primes = getPrimes(N >> 1)
pseudo = set()
twos = 2
while twos < N:
pseudo.add(getPseudo(twos))
k = 1
last = [twos]
while (len(last) > 0):
curr = []
p = primes[k]
for x in last:
t = x * p
while t < N:
curr.append(t)
t *= p
for x in curr:
pseudo.add(getPseudo(x))
last = curr
k += 1
twos <<= 1
return sum(pseudo)
def pr214():
def phi(n):
if isPrimeMR(n):
return n - 1
ret = n
for x in primes:
if x << 1 > n:
break
if n % x == 0:
ret = ret // x * (x - 1)
return ret
def getChainLen(n):
if d[n]:
return d[n]
t = getChainLen(phi(n)) + 1
d[n] = t
return t
primes = getPrimes(40000000)
d = [0] * 40000000
d[0] = 1
d[1] = 1
ret = 0
pbar = PBar(40000000).start()
for x in primes:
pbar.update(x)
if getChainLen(x) == 25:
ret += x
pbar.finish()
return ret
def pr249():
m = int(1e16)
primes = getPrimes(5000)
maxSum = sum(primes)
f = [0] * (maxSum + 1)
f[0] = 1
g = [0] * (maxSum + 1)
currSum = 0
for x in primes:
for i in range(currSum + 1):
if f[i]:
g[i + x] += f[i]
currSum += x
for i in range(currSum + 1):
f[i] = (f[i] + g[i]) % m
g[i] = 0
ret = 0
for x in getPrimes(maxSum):
ret += f[x]
return ret % m
def pr035(n):
def isCircularPrime(k):
k = str(k)
lst = [int((k[i:] + k[:i])) for i in range(len(k))]
return all(map(lambda x: x in primes, lst))
primes = set(getPrimes(n))
circularPrimes = [2]
for k in range(3, n + 1, 2):
if (k in primes) and isCircularPrime(k):
circularPrimes.append(k)
return len(circularPrimes)
def pr187(n):
primes = getPrimes(n)
i = 0
j = len(primes) - 1
while primes[i] * primes[j] >= n:
j -= 1
ret = 0
while i <= j:
ret += j - i + 1
i += 1
while primes[i] * primes[j] >= n:
j -= 1
return ret
def pr077():
N = 80
primes = getPrimes(N)
f = [0] * N
f[0] = 1
for x in primes:
for i in range(len(f)):
if i + x >= N:
break
if f[i]:
f[i + x] += f[i]
for i in range(len(f)):
if f[i] > 5000:
return i
def pr124():
def rad(n):
if isPrimeMR(n):
return n
ret = 1
for x in primes:
if x * 2 > n:
break
if n % x == 0:
ret *= x
return ret
primes = getPrimes(100000)
ret = list(range(1, 100001))
ret.sort(key = lambda x: (rad(x), x))
return ret[10000 - 1]
def pr060():
isValid = lambda a, b: isPrimeMR(int(str(a)+str(b))) and isPrimeMR(int(str(b)+str(a)))
p = getPrimes(10000)
pN = len(p)
for a in range(pN):
for b in range(a + 1, pN):
if isValid(p[a], p[b]):
for c in range(b + 1, pN):
if isValid(p[c], p[a]) and isValid(p[c], p[b]):
for d in range(c + 1, pN):
if isValid(p[d], p[a]) and isValid(p[d], p[b])\
and isValid(p[d], p[c]):
for e in range(d + 1, pN):
if isValid(p[e], p[d]) and isValid(p[e], p[c]) and\
isValid(p[e], p[b]) and isValid(p[e], p[a]):
print(p[a], p[b], p[c], p[d], p[e])
return p[a] + p[b] + p[c] + p[d] + p[e]
def pr357(n):
ret = 3
primes = set(getPrimes(2*n))
pbar = PBar(n).start()
for x in xrange(3, n + 1):
if not x in primes:
pbar.update(x)
flag = True
for y in xrange(1, int(sqrt(x))+1):
if (x % y == 0):
if not (y + x / y) in primes:
flag = False
break
if flag:
ret += x
pbar.finish()
return ret
def pr087(n):
primes = getPrimes(int(sqrt(n))+1)
p2 = set()
for k in primes:
if k ** 2 <= n:
p2.add(k**2)
p3 = set()
for k in primes:
for x in p2:
if k ** 3 + x <= n:
p3.add(k**3+x)
p4 = set()
for k in primes:
for x in p3:
if k ** 4 + x <= n:
p4.add(k**4+x)
return len([x for x in p4 if x <= n])
def pr347(N):
primes = getPrimes(N)
ret = 0
for i in range(len(primes) - 1):
p = primes[i]
j = i + 1
while p * primes[j] <= N:
pn = p
M = 0
while pn < N:
t = int(log(float(N)/pn) / log(primes[j]))
if not t:
break
if (pn * (primes[j] ** t) > M):
M = pn * (primes[j] ** t)
pn *= p
ret += M
j += 1
return ret
def pr047(factors, maxNum):
prime = getPrimes(maxNum)
factor = dict.fromkeys(range(maxNum + 1), 0)
for x in prime:
y = x
while y <= maxNum:
factor[y] = factor[y] + 1
y += x
for t in range(2, maxNum - factors):
flag = True
for y in range(factors):
if factor[t + y] != factors:
flag = False
break
if flag:
break
return t + factor[0]
def pr069(n):
def phi(n):
ret = 1
for x in primes:
if x > n:
break
if n % x == 0:
k = 0
while (n % x == 0):
k += 1
n //= x
ret *= (x**(k-1))*(x-1)
return ret
maxPhi = 0
maxN = 0
primes = getPrimes(n+1)
for i in range(2, n+1):
t = float(i) / phi(i)
if t > maxPhi:
maxPhi = t
maxN = i
return maxN
def pr037():
def pIter():
k = 9
while True:
if pDict.get(k, False):
yield k
k += 2
def genPrime(n):
k = 3
while k <= n:
while not pDict.get(k, True): k += 2
if k > n : break
pDict[k] = True
t = k * 2
while t <= n:
pDict[t] = False
t += k
k += 2
def isVaild(x):
t = x // 10
while t > 0:
if not pDict.get(t):
return False
t //= 10
t = str(x)[1:]
while t:
if not pDict.get(int(t)):
return False
t = t[1:]
return True
pDict = dict.fromkeys(getPrimes(2000000), True)
ret = []
prime = pIter()
for _ in range(11):
p = next(prime)
while not isVaild(p):
p = next(prime)
ret.append(p)
return sum(ret)
def pr123(exceed):
def powerMod(b, e, m):
if e == 0:
return 1
if e == 1:
return b % m
if e & 1 == 0:
return powerMod(b * b % m, e >> 1, m)
else:
return (powerMod(b * b % m, e >> 1, m) * b) % m
primes = getPrimes(int(1e6))
t = int(exceed ** 0.5)
for n in count(0):
if primes[n] >= t:
break
while True:
p = primes[n]
m = p * p
if (powerMod(p - 1, n + 1, m) + powerMod(p + 1, n + 1, m)) % m >= exceed:
return n + 1
n += 1
return "FAILED"
def pr010_2(n):
from usr import getPrimes
return sum(getPrimes(n))
