def f(n, k=-1):
if k < 0 or k > sqrt(n):
k = int(sqrt(n))
if (n, k) in res:
return res[(n, k)]
if k < 2: return 0
s = 0
for p in sieve_primes(k + 1):
m = n / (p * p)
s += m - f(m, p - 1)
res[(n, k)] = s
return s
def main():
MAX = 1000000
best = (0, 0)
primes = list(sieve_primes(MAX))
sums = build_sums(primes)
for first in range(0, len(sums)):
last = len(sums)
while last - first > best[1]:
curr_sum = calc_curr_sum(first, last, sums)
if is_prime(curr_sum):
best = (curr_sum, last - first)
break
last -= 1
print(best)
from collections import defaultdict
from common import sieve_primes
factors, lim = defaultdict(list), 100000
primes = list(sieve_primes(lim))
for n in range(2, lim):
i, prime_list, m, solved = 0, [], n, False
while m not in primes:
if factors[m]:
prime_list.extend(factors[m])
solved = True
break
if n % primes[i] == 0:
prime_list.append(primes[i])
m //= primes[i]
else: i += 1
if not solved:prime_list.append(m)
factors[n] = prime_list
print(factors[46])
from _collections import defaultdict
from common import sieve_primes, is_prime
primes, mod = sieve_primes(10), 10**16
ss = defaultdict(int)
ss[0] = 1
for prime in primes:
for key in sorted(ss.keys(), reverse=True):
ss[key + prime]+=ss[key]
print(sum(ss[s] for s in ss if is_prime(s)))
from collections import defaultdict
import sys
from common import is_prime, Watch, sieve_primes, d_count
Watch.start()
lim = 10000
primes, cat, graph = list(sieve_primes(lim)), lambda x, y: x * 10 ** d_count(y) + y, defaultdict(set)
primes.remove(2)
primes.remove(5)
for i, p1 in enumerate(primes):
for p2 in primes[i + 1:]:
if is_prime(cat(p1, p2)) and is_prime(cat(p2, p1)):
graph[p1].add(p2)
max_sum = sys.maxsize
for a in primes:
xa = graph[a]
for b in xa:
xb = xa & graph[b]
for c in xb:
xc = xb & graph[c]
for d in xc:
xd = xc & graph[d]
for e in xd:
max_sum = min(max_sum, a + b + c + d + e)
print(max_sum)
Watch.stop()
from common import sieve_primes
primes = set(sieve_primes(1000000))
for n in range(2, 500):
t = 2 * n * n - 1
if t not in primes:
print(t, divmod(t, 7))
from math import sqrt, ceil, floor
from common import sieve_primes, Watch
Watch.start()
N = 999966663333
primes, sum, i = list(sieve_primes(2 * ceil(sqrt(N)))), 0, 0
while primes[i]*primes[i] < N:
p1, p2, i = primes[i], primes[i + 1], i + 1
for n in range(p1 + 1, floor(p2 * p2 / p1) + 1):
k = n * p1
if k >= N: break
if n != p2: sum += k
for n in range(ceil(p1 * p1 / p2), p2):
k = n * p2
if k >= N: break
if n!= p1: sum += k
print(sum)
Watch.stop()
from common import sieve_primes print(list(sieve_primes(500000))[10001])
from math import sqrt
from common import Watch, is_prime, sieve_primes
Watch.start()
lim = 1000000
#this bound is purely heuristic and might not work for some limits
prime_lim = lim // int(sqrt(lim)) * 10
primes = list(sieve_primes(prime_lim))
end, max_len, s, max_s = 0, 0, 0, 0
while s < lim:
if is_prime(s):
max_len, max_s = end, s
s, end = s + primes[end], end + 1
start, end, s = 1, max_len, max_s - primes[0] + primes[max_len]
while s < lim:
new_s, new_end = s, end
while new_s < lim:
if is_prime(new_s) and new_end - start > max_len:
max_len, max_s = new_end - start, new_s
new_end += 1
new_s += primes[new_end]
start, end = start + 1, end + 1
s += primes[end] - primes[start - 1]
print(max_s)
Watch.stop()
from common import sieve_primes print(sum(sieve_primes(2000000)))
