def euler10(target=2000000):
"""http://projecteuler.net/problem=10
The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
Find the sum of all the primes below two million.
"""
return sum(sieve(target))
def main():
primeArray = sieve(1000)
limit = len(primeArray)
n = 100
# n = 10000 # possible improvement, as we search closer to the answer
noDivsC1 = 2 # number of divisors of the "n" component
d = 0
while d < 500:
n += 1
aux = n
noDivsC2 = 1 # number of divisors of the "n+1" component
if aux % 2 == 0:
aux /= 2
for i in range(0, limit):
if primeArray[i] * primeArray[i] > aux:
noDivsC2 *= 2
break
exponent = 1
while aux % primeArray[i] == 0:
exponent += 1
aux = aux / primeArray[i]
if exponent > 1:
noDivsC2 *= exponent
if aux == 1:
break
d = noDivsC1 * noDivsC2
# the number of divisors of the "n+1" component can be reused in the
# next step
noDivsC1 = noDivsC2
print n * (n - 1) / 2 # the actual number, remember Problem 6?
return 0
def euler35(upper_bound=1000000):
"""http://projecteuler.net/index.php?section=problems&id=35
Find the sum of all numbers less than one million, which are palindromic in
base 10 and base 2."""
global primes
primes = set(sieve(upper_bound))
return sum(cyclic_prime(x) for x in primes)
def euler37(upper_bound=1000000):
"""http://projecteuler.net/index.php?section=problems&id=37
Find the sum of all eleven primes that are both truncatable from left to
right and right to left."""
global primes
primes = set(sieve(upper_bound))
return sum(n for n in primes if is_truncatable(n))
def euler187(ub=10 ** 8):
"""http://projecteuler.net/problem=187
A composite is a number containing at least two prime factors. For example,
15 = 3 × 5; 9 = 3 × 3; 12 = 2 × 2 × 3.
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?
"""
small_primes = sieve(int(ub ** 0.5))
big_primes = sieve(ub / 2)
total = 0
for x in range(len(small_primes)):
total += bisect(big_primes, ub / small_primes[x]) - x
return total
def count_combinations(limit):
primes = sieve(int(limit ** 0.5))
squares = [p ** 2 for p in primes if p ** 2 < limit]
cubes = [p ** 3 for p in primes if p ** 3 < limit]
fourths = [p ** 4 for p in primes if p ** 4 < limit]
results = set()
for s in squares:
for c in cubes:
for f in fourths:
if s + c + f < limit:
results.add(s + c + f)
return len(results)
def euler7(n=10001):
"""http://projecteuler.net/problem=7
By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see
that the 6th prime is 13.
What is the 10001st prime number?
"""
# Find all primes less than some initial guess. If that doesn't provide
# enough primes, try again with a bigger guess.
primes, guess = [], 1000000
while len(primes) < n:
primes, guess = sieve(guess), guess * 2
return primes[n - 1]
def main(nr):
N = 1
check = True
limit = sqrt(nr)
p = sieve(nr)
a = [1] * nr
for i in range(len(p)):
if check:
if p[i] <= limit:
a[i] = floor(log(nr) / log(p[i]))
else:
check = False
N *= p[i] ** a[i]
print int(N)
return 0
def euler46():
"""http://projecteuler.net/index.php?section=problems&id=46
What is the smallest odd composite that cannot be written as the sum of a
prime and twice a square?"""
double_squares = [2*n*n for n in range(1000)]
primes = set(sieve(10 ** 6))
for n in range(2, 10 ** 6):
found = False
for ds in double_squares:
if ds > n: break
if n-ds in primes:
found = True
break
if not found and n % 2 == 1: return n
def euler49():
"""http://projecteuler.net/index.php?section=problems&id=49
Find arithmetic sequences, made of prime terms, whose four digits are
permutations of each other."""
primes = [prime for prime in sieve(10000) if prime > 999]
prime_digits = [list(str(prime)) for prime in primes]
for prime in prime_digits:
prime.sort()
prime_digits = [''.join(prime) for prime in prime_digits]
for i in range(len(primes)):
for j in range(i+1, len(primes)):
if prime_digits[i] != prime_digits[j]: continue
if 2 * primes[j] - primes[i] not in primes: continue
x = 2 * primes[j] - primes[i]
k = list(str(x))
k.sort()
k = ''.join(k)
if (k == prime_digits[i]):
if primes[i] != 1487:
return str(primes[i]) + str(primes[j]) + str(x)
def euler60():
"""http://projecteuler.net/problem=60
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.
"""
primes = sieve(10000) # turns out 10k is enough for a set of 5.
for p1 in primes:
for p2 in primes:
if p2 <= p1 or not concat_prime(p1, p2): continue
for p3 in primes:
if p3 <= p2 or not concat_primes(p3, [p1, p2]): continue
for p4 in primes:
if p4 <= p3 or not concat_primes(p4, [p1, p2, p3]): continue
for p5 in primes:
if p5 <= p4 or not concat_primes(p5, [p1, p2, p3, p4]): continue
return sum([p1, p2, p3, p4, p5])
from euler_util import sieve
from itertools import combinations
primes = set(p for p in sieve(10 ** 6) if p > 10 ** 5)
templates = list(combinations(range(6), 3))
def fill_template(base, template, number):
base = list(base)
for index in template:
base[index] = number
return int("".join(base))
def test_templates(base, target=8):
for template in templates:
prime_substitutions = 0
for i in range(10):
if fill_template(str(base), template, str(i)) in primes:
prime_substitutions += 1
if prime_substitutions >= target:
return fill_template(str(base), template, "1")
return False
def euler51():
"""http://projecteuler.net/problem=51
By replacing the 1st digit of *3, it turns out that six of the nine
possible values: 13, 23, 43, 53, 73, and 83, are all prime.
def main(*args, **kwargs):
print reduce(add, sieve(2000000))
return 0
from euler_util import sieve
primes = set(sieve(10 ** 6))
def quad_score(a, b):
score = 0
while score*score + a*score + b in primes: score += 1
return score
def euler27():
"""http://projecteuler.net/index.php?section=problems&id=27
Find a quadratic formula that produces the maximum number of primes for
consecutive values of n."""
best_a, best_b, best_score = 0, 0, 0
for a in range(-999, 1000):
for b in range(-999, 1000):
score = quad_score(a, b)
if score > best_score:
best_a, best_b, best_score = a, b, score
return best_a * best_b
# coding=utf8
from euler_util import sieve
primes = sieve(1000)
def euler69(upper_bound=1000000):
"""http://projecteuler.net/problem=69
Find the value of n <= 1,000,000 for which n/φ(n) is a maximum."""
# Note: here is the brute force approach:
# return max(zip(map(lambda x: float(x)/totient(x),
# xrange(1, ub)), xrange(1, ub)))
# to do this more cleverly, realize that we minimize phi(n) when n is a
# product of the first n primes.
value = 1
for p in primes:
value *= p
if value > upper_bound: return value/p
