def sum_truncatable_primes(n, r, i=4, t=[]):
primes = prime_sieve(r)
while len(t) < n:
if truncatable_prime(primes[i]):
t.append(primes[i])
i += 1
return sum(t)
def problem_69(r, m=1):
# find the product of consecutive primes under r
primes = prime_sieve(50)
for x in primes:
if m * x > r:
return m
m *= x
def compute():
limit = 10 ** 6
primes = prime_sieve(limit)
n = 7035
while (2 * n * primes[n-2]) % (primes[n-2] ** 2) < 10 ** 10 and n < limit:
n += 1
return n
def get_n_digit_primes(n):
prime_list = []
for i in prime_sieve(10**n):
if num_digits(i) == n:
prime_list.append(i)
return prime_list
def compute():
target = 5000
values = list(prime_sieve(target))
i = 2
while ways_to_sum(i, values) <= target:
i += 1
return i
def compute():
candidates = list(prime_sieve(7654321))
''' Pandigital numbers with 8 or 9 digits are always divisible by 3
so the solution can have at most 7 digits
'''
for i in range(len(candidates)-1,1,-1):
n = candidates[i]
if is_pandigital(n):
return n
def compute():
limit = 10 ** 8
primes = prime_sieve(limit / 2 + 1)
primes_iter = [p for p in primes if p ** 2 < limit]
count = 0
for i in primes_iter:
primes = [p for p in primes if i * p < limit and p >= i]
count += len(primes)
return count
def compute():
limit = 10000
primes = prime_sieve(limit)
squares = [2 * j**2 for j in range(int(limit**0.5))]
S = set(range(3, limit, 2)) - set(primes)
for p in primes:
for s in squares:
S.discard(s+p)
if len(S) == 0:
return -1
else:
return min(S)
def generate_list(primes, limit):
result = []
for i, val in enumerate(primes):
higher_primes = [k for k in prime_sieve(limit) if k > max(val)]
for j in higher_primes:
if p060(val, j):
s_list = [] # list of successful pairings
[s_list.append(l) for l in val]
s_list.append(j)
result.append(s_list)
return result
def compute():
composites = set(range(6, 10**6)) - set(prime_sieve(10**6))
count = 0
ans = 0
for c in composites:
if gcd(c, 10) == 1:
if (c-1) % A(c) == 0:
ans += c
count += 1
if count == 25:
break
return ans
def get_answer():
''' '''
max_value = 10**8
# get all prime factors that could be 2 factor
primes = sorted(euler.prime_sieve(max_value/2 + 10**6))
two_factor_count, max_index = 0, len(primes)
for i, prime0 in enumerate(primes):
limit = 10**8 / prime0;
j = i
while j <= max_index and primes[j] <= limit:
two_factor_count += 1
j += 1
print 'two_factor_count: {}'.format(two_factor_count)
def compute():
i = 647
limit = 1000000
run = 0
i_run = 0
primes = set(prime_sieve(limit))
while run < 4:
factors = list_divisors(i)
factors = [f for f in factors if (f % 2 == 1 or f == 2) and f in primes]
if len(factors) == 4:
if run == 0:
i_run = i
run += 1
else:
run = 0
i += 1
return i_run
def compute():
limit = 50 * 10**6
primes_2 = list(prime_sieve(int(limit**0.5)))
primes_3 = list(filter(lambda x: x < limit**(1.0 / 3.0), primes_2))
primes_4 = list(filter(lambda x: x < limit**(1.0 / 4.0), primes_2))
sums_2 = sorted([primes_2[i]**2 for i in range(len(primes_2))])
sums_34 = sorted([primes_3[i]**3 + primes_4[j]**4 for i in range(len(primes_3)) for j in range(len(primes_4))])
sums = set()
for i in range(len(sums_34)):
for j in range(len(primes_2)):
temp = sums_2[j] + sums_34[i]
if temp >= limit:
break
sums.add(temp)
return len(sums)
def compute():
def find_arithmetic_sequence(L):
L.sort()
for i in range(len(L)):
for j in range(i + 1,len(L)):
for k in range(j + 1, len(L)):
if L[k] - L[j] == L[j] - L[i]:
return [L[i], L[j], L[k]]
return -1
primes = set(prime_sieve(10000)) - set(range(1000)) - {1487, 4817, 841}
primes_lookup = {}
for p in primes:
key = int("".join(sorted(list(str(p)))))
if key in primes_lookup:
primes_lookup[key].append(p)
else:
primes_lookup[key] = [p]
candidates = [x for x in list(primes_lookup.values()) if len(x) > 2]
return [find_arithmetic_sequence(L) for L in candidates if find_arithmetic_sequence(L) != -1][0]
# https://projecteuler.net/problem=50
from euler import prime_sieve, is_prime
from time import time
T = time()
limit = 1000000
primes = []
for i in prime_sieve(limit):
primes.append(i)
# first find upper bound of consecutive primes:
running_sum = 0
upper_bound = 0
for i, val in enumerate(primes):
running_sum += val
if running_sum > limit:
upper_bound = i # the upper bound on number of consecutive primes given a limit
break
# start with the upper bound and remove one prime at a time
sum_of_primes = 0
largest_jump = 0
largest_prime = 2
for i in range(0, len(primes)):
for j in range(upper_bound, 1, -1):
sum_of_primes = sum(primes[i:j])
if is_prime(sum_of_primes) and largest_jump < j-i:
largest_jump = j-i
largest_prime = sum_of_primes
break
# coding=utf-8
'''
Problem 49
01 August 2003
The arithmetic sequence, 1487, 4817, 8147, in which each of the terms increases by 3330, is unusual in two ways: (i) each of the three terms are prime, and, (ii) each of the 4-digit numbers are permutations of one another.
There are no arithmetic sequences made up of three 1-, 2-, or 3-digit primes, exhibiting this property, but there is one other 4-digit increasing sequence.
What 12-digit number do you form by concatenating the three terms in this sequence?
'''
import euler, collections, itertools, math
prime_sets = collections.defaultdict(list)
for prime in euler.prime_sieve(10**4):
if (prime > 1000):
key = tuple(sorted(str(prime)))
prime_sets[key].append(prime)
for prime_set in prime_sets.itervalues():
if (len(prime_set) >= 3):
for pset in itertools.permutations(prime_set, 3):
if (pset[2]-pset[1] == pset[1]-pset[0]) and (pset[0] < pset[1]):
print ''.join(str(i) for i in pset)
def compute():
return sum(prime_sieve(2000000))
# 142913828922 import euler N = 2000000 sieve = euler.prime_sieve(N) print sum([p for p in xrange(N) if sieve[p]])
# coding=utf-8
'''
Problem 37
14 February 2003
The number 3797 has an interesting property. Being prime itself, it is possible to continuously remove digits from left to right, and remain prime at each stage: 3797, 797, 97, and 7. Similarly we can work from right to left: 3797, 379, 37, and 3.
Find the sum of the only eleven primes that are both truncatable from left to right and right to left.
NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes.
'''
import euler
def truncatable_prime(n):
if n < 10: return False
for i in range(1, len(str(n))):
if not euler.is_prime(int(str(n)[i:])) or not euler.is_prime(
int(str(n)[:-i])):
return False
return True
print sum(i for i in euler.prime_sieve(10**6) if truncatable_prime(i))
import euler
prime_list = [x for x in euler.prime_sieve(1000000)]
def rotate_left(num):
num = str(num)
first_digit = num[0]
return num[1:] + first_digit
#euler.is_prime(rotate_left(prime))
def check_prime(num):
length = len(str(num))
inc = 1
while inc < length:
num = rotate_left(num)
if not euler.is_prime(int(num)):
return False
inc += 1
# print num
return True
answer = []
count = 0
for prime in prime_list:
if check_prime(prime):
count += 1
answer.append(prime)
print count
print answer
from euler import prime_sieve, multiply_polynomials
primes = prime_sieve(10000)
for i in range(12,500):
result = map(lambda x:int(x%2==0),[j for j in range(i+1)])
for j in primes:
if j > i:
break
elif j == 2:
continue
else:
tmp = map(lambda x:int(x%j==0),[k for k in range(i+1)])
result = multiply_polynomials(result,tmp)
if result[i] > 5000:
print "%d can be written as the sum of primes in %d ways" % (i, result[i])
import euler
# using fermats theorem
primes = list(euler.prime_sieve(1000))
def cycle_length(d):
cyc_len = None
n = 0
while cyc_len is None and n < d:
n += 1
if pow(10, n, d) == 1:
cyc_len = n
return (n)
max_cycle = 0
max_d = 0
for d in reversed(primes):
cyc = cycle_length(d)
if max_cycle < cyc:
max_cycle = cyc
max_d = d
if max_cycle > d:
break
print(max_d)
print(max_cycle)
#!/usr/bin/python -tt ''' problem 111: http://projecteuler.net/problem=111 ''' from euler import prime_sieve max_prime = 10**(4) p = prime_sieve(max_prime)
# brute force:
max_value = 0
max_value_num = 2
for num in range(2, 10**6+1):
n_div_phi = num/phi(num)
if n_div_phi > max_value:
max_value = n_div_phi
max_value_num = num
print(max_value_num)
print("time elapsed:", time() - T)
"""
Pen and paper method:
Notice that n/phi(n) = 1/((1-1/p1)*(1-1/p2)...)
Hence n/phi(n) is maximal when ((1-1/p1)*(1-1/p2)...) is minimal
This happens using the smallest primes, so we simply multiply the
smallest primes together and make sure we stay under 10^6
"""
T = time()
s = 1
for i in prime_sieve(100):
s *= i
if s > 10**6:
print(s // i)
break
print('time elapsed:', time() - T)
from math import floor
from euler import prime_sieve
from time import time
T = time()
square_max = floor(50**(1/2)*10**(6/2))
cube_max = floor(50**(1/3)*10**(6/3))
fourth_max = floor(50**(1/4)*10**(6/4))
limit = 50*10**6
numbers = []
# can be optimized by just having one list of primes,
# this is sufficient for the task at hand, however
for i in prime_sieve(square_max):
for j in prime_sieve(cube_max):
for k in prime_sieve(fourth_max):
num = (i**2 + j**3 + k**4)
if num < limit:
numbers.append(num)
print(len(set(numbers)))
print("time elapsed:", time() - T)
from euler import prime_sieve, isprime
import time
def is_square(n):
x = int((n / 2)**0.5)
if 2 * x * x == n:
return True
else:
return False
start = time.time()
num = 3
result = 0
while True:
flag = False
if not isprime(num):
for item in prime_sieve(num):
if is_square(num - item):
flag = True
break
if not flag:
result = num
break
num += 2
spend = time.time() - start
print "The result is %s and take time is %f" % (result, spend)
# coding=utf-8
'''
Problem 35
17 January 2003
The number, 197, is called a circular prime because all rotations of the digits: 197, 971, and 719, are themselves prime.
There are thirteen such primes below 100: 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, and 97.
How many circular primes are there below one million?
'''
import euler
primes = dict.fromkeys(euler.prime_sieve(10**6), True)
def is_circular_prime(n):
x = str(n)
for i in range(0, len(x)):
if int(x[i:] + x[:i]) not in primes:
return False
return True
print sum(1 for n in primes if is_circular_prime(n))
# coding=utf-8
'''
Problem 35
17 January 2003
The number, 197, is called a circular prime because all rotations of the digits: 197, 971, and 719, are themselves prime.
There are thirteen such primes below 100: 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, 73, 79, and 97.
How many circular primes are there below one million?
'''
import euler
primes = dict.fromkeys(euler.prime_sieve(10**6), True)
def is_circular_prime(n):
x = str(n)
for i in range(0, len(x)):
if int(x[i:] + x[:i]) not in primes:
return False
return True
print sum(1 for n in primes if is_circular_prime(n))
from euler import prime_sieve
def quad_form(n, a, b):
return n**2 + a * n + b
max_n = 1000
max_a = 1000
max_b = 1001
primes = list(prime_sieve(quad_form(max_n, max_a, max_b)))
b_vals = list(prime_sieve(max_b))
best = [0, 0, 0]
for b in b_vals:
print(b)
a_vals = filter(lambda a: a < b, map(lambda p: p - b - 1, primes))
for a in a_vals:
n = 0
while quad_form(n, a, b) in primes:
n += 1
if n > best[2]:
best = [a, b, n]
print(best)
print(best[0] * best[1])
# -59231
import euler
N = 1000
M = 80
m = -1
ab = 0
sieve = euler.prime_sieve(M * M + M * N + N)
for a in xrange(1-N, N):
for b in xrange(2, N):
n = 0
while True:
c = n * n + a * n + b
if c < 2 or not sieve[c]:
if n > m:
m = n
ab = a * b
break
n += 1
print ab
import time
from euler import prime_sieve
start = time.time()
result = 1
for i in prime_sieve(20):
result *= i
result = result*2*2*2*3
# from 1-20 they are prime:2,3,5,7,11,13,17,19
# analysis the other we need 2**4 and 3**2
time_take = time.time() - start
print "The sum is %s and take time is %f" %(result , time_take)
# coding=utf-8
'''
Problem 50
15 August 2003
The prime 41, can be written as the sum of six consecutive primes:
41 = 2 + 3 + 5 + 7 + 11 + 13
This is the longest sum of consecutive primes that adds to a prime below one-hundred.
The longest sum of consecutive primes below one-thousand that adds to a prime, contains 21 terms, and is equal to 953.
Which prime, below one-million, can be written as the sum of the most consecutive primes?
'''
import euler
primes = euler.prime_sieve(10**4)
longest = primesum = 1
for i in range(len(primes)):
for j in range(i + longest, len(primes)):
if (sum(primes[i:j]) < 10**6) and euler.is_prime(sum(primes[i:j])):
longest = j - i
primesum = sum(primes[i:j])
print primesum
from euler import isprime
from euler import prime_sieve
import time
def circular(n):
num = str(n)
for i in range(len(str(n))):
cirnum = int(num[i:] + num[:i])
if not isprime(cirnum):
return False
return True
start = time.time()
result = sum([1 for i in prime_sieve(10**6) if circular(i)])
time_spend = time.time() - start
print "The result is %d and time used is:%f s" % (result, time_spend)
# April 25, 2016
# Fermat's Little Theorem
# 1/d has a cycle of n digits if 10^n - 1 mod d = 0 for prime d
from euler import prime_sieve
for d in list(prime_sieve(1000))[::-1]:
period = 1
while pow(10, period, d) != 1:
period += 1
if d - 1 == period:
break
print d
# coding=utf-8
"""
Problem 37
14 February 2003
The number 3797 has an interesting property. Being prime itself, it is possible to continuously remove digits from left to right, and remain prime at each stage: 3797, 797, 97, and 7. Similarly we can work from right to left: 3797, 379, 37, and 3.
Find the sum of the only eleven primes that are both truncatable from left to right and right to left.
NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes.
"""
import euler
def truncatable_prime(n):
if n < 10:
return False
for i in range(1, len(str(n))):
if not euler.is_prime(int(str(n)[i:])) or not euler.is_prime(int(str(n)[:-i])):
return False
return True
print sum(i for i in euler.prime_sieve(10 ** 6) if truncatable_prime(i))
def sum_of_primes(m):
return sum(prime_sieve(m))
def count_circular_primes(r, c=0):
for x in prime_sieve(r):
if circular_prime(x):
c += 1
return c
from euler import prime_sieve import time start = time.time() result = sum(prime_sieve(2 * 10**6)) time_take = time.time() - start print "The sum is %s and take time is %f" % (result, time_take)
from euler import isprime
from euler import prime_sieve
import time
def trunc(n):
num = str(n)
for i in range(len(str(n))):
cirnum = int(num[i:])
if not isprime(cirnum):
return False
for i in range(len(str(n))):
cirnum = int(num[:len(num) - i])
if not isprime(cirnum):
return False
return True
start = time.time()
result = sum([i for i in prime_sieve(10**6) if trunc(i)]) - 2 - 3 - 5 - 7
time_spend = time.time() - start
print "The result is %d and time used is:%f s" % (result, time_spend)
T = time()
def is_permutation(n1, n2):
if sorted(str(n1)) == sorted(str(n2)):
return True
else:
return False
n_max = 10**7
search_range = 1000
search_start = floor(sqrt(n_max)) - search_range
search_end = floor(sqrt(n_max)) + search_range
prime_list = []
for prime in prime_sieve(search_end):
if prime > search_start:
prime_list.append(prime)
candidate = 1
smallest_ratio = 10
for i in range(len(prime_list)):
for j in range(i, len(prime_list)):
n = prime_list[i]*prime_list[j]
if n >= 10**7:
break
phi_n = phi(n)
ratio = n/phi_n
if is_permutation(n, phi(n)) and ratio < smallest_ratio:
candidate = n
smallest_ratio = ratio
from euler import prime_sieve, truncations
primes=set(prime_sieve(1000000))
def compute():
def is_truncated_prime(n):
if n in [2, 3, 5, 7]:
return False
return all([p in primes for p in truncations(n)])
return sum([p for p in primes if is_truncated_prime(p)])
if __name__ == "__main__":
print(compute())