def solve(N, ceiling):
primes = sieve_eratosthenes(ceiling)
print('Sieve prepared')
mp = {}
K = int(math.log10(ceiling))
for k in range(2, K):
print('k=' + str(k))
for p in primes:
for starred_number in transform_starred(p, k):
try:
mp[starred_number].append(p)
except KeyError, e:
mp[starred_number] = [p]
def solve(N):
result = 0 #@UnusedVariable
primes = sieve_eratosthenes(N)
print('Number of primes: ' + str(len(primes)))
start = time.clock()
max_consecutive_primes = [2]
len_max_consecutive_primes = len(max_consecutive_primes)
# special treatment for prime sequences starting with 2
s = 0
for i in range(0, len(primes)):
s += primes[i]
if s in primes:
max_consecutive_primes = primes[:i+1]
len_max_consecutive_primes = len(max_consecutive_primes)
if s > N:
break
print(len_max_consecutive_primes, sum(max_consecutive_primes), max_consecutive_primes)
# all following sequence lengths must be odd
if len_max_consecutive_primes % 2 == 0:
len_max_consecutive_primes += 1
for i in range(1, len(primes)):
cons_primes = primes[i:i + len_max_consecutive_primes + 2]
cons_sum = sum(cons_primes)
for j in range(i+ len_max_consecutive_primes + 2, len(primes)-1, 2):
cons_primes += primes[j:j+2]
cons_sum += primes[j] + primes[j+1]
if cons_sum > N:
break
if cons_sum in primes:
max_consecutive_primes = [p for p in cons_primes]
print(len_max_consecutive_primes, sum(max_consecutive_primes), max_consecutive_primes)
if i % 5000 == 0:
print(i, time.clock() - start)
result = sum(max_consecutive_primes)
print(time.clock() - start)
print("The highest prime sum of the most consecutive primes below %(N)d is %(result)d" % vars())
def solve(N):
primes = sieve_eratosthenes(lsqrt(N)*2)
print_sieve_stats(primes)
min_frac = N
min_number = N
for step in range(1, 500):
for (p, q) in [(primes[i], primes[i-step]) for i in range(len(primes)-1, step-1, -1)]:
for (p_power, q_power) in zip(powers_below(p, N), powers_below(q, N)):
n = p_power*q_power
if n > N:
continue
phi = (p_power - p_power/p)*(q_power - q_power/q)
if permutation.is_permuted(n, phi):
frac = float(n)/phi
if frac < min_frac:
print(n, p, q, phi, frac, step)
min_frac = frac
min_number = n
return min_number
if n1s == n2s: return True
return False
# Big primes will be the closest to 1 for p/phi(p), since the
# difference between p and phi(p) is pretty much negligible, but
# primes will never be permutations of their phi(p) values.
# product of two primes should still be relatively close to 1 for n/phi(n)
# compared to normal numbers.
# phi(p) = p-1 and phi(pq) = phi(p) * phi(q) so products of primes is good for
# the math too.
# Obviously we need to keep our products of primes below the limit,
# and the bigger the primes, the smaller the n/phi(n).
limit = 10**7
minimum = 1000000
ans = 0
primes = sieve_eratosthenes(int((limit**0.5)*2))
for pp in product(primes[100:], repeat=2):
n = pp[0]*pp[1]
if n > limit: continue
phi_n = (pp[0]-1)*(pp[1]-1)
if compare(n,phi_n):
div = float(n)/phi_n
if div < minimum:
minimum = div
ans = n
print ans
print time()-start
def solve(D):
primes = sieve_eratosthenes(D)
factorizations = list(factorizations_below(D, primes))
assert len(factorizations)+1 == D
return sum([phi_of_factorization(factorization) for factorization in factorizations])
def solve(D, i):
primes = sieve_eratosthenes(D)
l = list(factorizations_below(D, primes)) + [((1,1),)]
E = sorted([(num(factors), rad(factors)) for factors in l], cmp_rad)
return E[i-1][0]
"""
from sieve import sieve_eratosthenes
from projecteuler import list_to_dict
from itertools import product
from itertools import takewhile
def quadratics(a,b, start):
# produces sequence: n^2 + an + b
n = start
while(1):
yield n**2 + a*n + b
n += 1
if __name__ == '__main__':
primes = list_to_dict(sieve_eratosthenes(10**6), True)
print("Prepared sieve")
(ma, mb, mn) = (0,0,0)
for (a, b) in product(range(-1000,1000), repeat=2):
if not (mn**2 + a*mn + b) in primes:
continue
consecutive_primes = list(takewhile(lambda q: q in primes, quadratics(a,b, 0)))
if(len(consecutive_primes) > mn):
(ma, mb, mn) = (a, b, len(consecutive_primes))
result = ma*mb
print("The coefficients, a and b, for the quadratic expression that produces the maximum number of primes for consecutive values of n are (%(ma)d, %(mb)d)" % vars())
print("Their product is %(result)d" % vars())
