def p46(): #getting precalculated primes and squares: u = Utils() primes = u.sieve(6000) squares = [i * i for i in range(1, 101)] #start searching at 15: o = 15 while o < 5800: #is the test number prime? if u.chop(o, primes) != -1: #yeap, go to next one: o += 2 continue #nope, begin testing: ind = 0 found = False while o - primes[ind] > 0: s = (o - primes[ind]) / 2 #found desired decomposition? if u.chop(s, squares) != -1: #yep, break out: found = True break #nope, try next prime: else: ind += 1 #found possible candidate: if not found: print o #keep searching: o += 2
def p35():
u = Utils()
sieve = u.sieve(10 ** 6)
count = 0
for prime in sieve:
s = str(prime)
l = cyclic_shifts_of(s)
if all_in(l, sieve, u):
count += 1
return count
def p37():
u = Utils()
primes = u.sieve(10 ** 6)
total = 0
for p in primes:
a = is_right_truncatable(p, u, primes)
b = is_left_truncatable(p, u, primes)
if a and b:
total += p
#we have to ignore 2, 3, 5, and 7, which sum up to 17:
print total - 17
def p127(max_c, exp):
u = Utils()
primes = u.sieve(max_c)
radicals = rad(int(max_c), primes)
possible_ys = [i for i in range(1, max_c) if radicals[i] <= int(max_c ** exp)]
possible_rads = [radicals[i] for i in possible_ys]
print("len(radicals):", len(radicals))
print("len(possible_ys):", len(possible_ys))
print(possible_ys)
print(possible_rads)
total = 0
for a in possible_ys:
for b in possible_ys:
c = a + b
if a < b and c < max_c and hit(a, b, c, radicals):
print(a,b,c)
total += c
print(total)
#Consider the consecutive primes p1 = 19 and p2 = 23. It can be verified that
#1219 is the smallest number such that the last digits are formed by p1 whilst
#also being divisible by p2.
#
#In fact, with the exception of p1 = 3 and p2 = 5, for every pair of consecutive
#primes, p2 > p1, there exist values of n for which the last digits are formed by
#p1 and n is divisible by p2. Let S be the smallest of these values of n.
#
#Find S for every pair of consecutive primes with 5 <= p1 <= 1000000.
from utils import Utils
u = Utils()
a = u.sieve(1100000)
"""
It is assumed that n is a power of 10.
"""
def phi(n):
return (2 * n) / 5
def f1(p1, p2):
m = len(str(p1))
r = 10 ** m
q = phi(r) - 1
s = pow(p2, q, r)
return ((((p1 * p2 * s) / r) % p2) * r) + p1
l = [f1(a[i], a[i + 1]) for i in range(2, len(a) - 1) if a[i] < 10 ** 6]
print sum(l)
#coding: UTF-8
#Let p_n be the nth prime: 2, 3, 5, 7, 11, ..., and let r
#be the remainder when (p_n − 1)^n + (p_n + 1)^n is divided
#by p_n^2.
#
#For example, when n = 3, p_3 = 5, and 4^3 + 6^3 = 280
#≡ 5 mod 25.
#
#The least value of n for which the remainder first exceeds
#10^9 is 7037.
#
#Find the least value of n for which the remainder first
#exceeds 10^10.
from utils import Utils
u = Utils()
p = u.sieve(4 * (10 ** 5))
def p123():
i = 0
a = 0
while a < 10 ** 10 and i < len(p):
i += 1
a = (2 * p[i] * (i + 1)) % (p[i] ** 2)
#sum 2 because i is the index of the number just below
#10 ** 10, and array indices start by 0:
print i + 2
u.exec_time(p123)
#a perfect cube.
#
#For example, when p = 19, 8^3 + 8^2×19 = 12^3.
#
#What is perhaps most surprising is that for each prime with
#this property the value of n is unique, and there are only
#four such primes below one-hundred.
#
#How many primes below one million have this remarkable
#property?
from utils import Utils
cube_list = [x ** 3 for x in range(578)]
u = Utils()
prime_list = u.sieve(10 ** 6)
def p131():
"""
As taken from the forum:
Since x^3 = n^2(n + p), and p is a prime, it turns
out that n must be a cube, as well as n + p, i.e.,
we must have p = a^3 - b^3 for some a, b.
But, for a^3 - b^3 = (a - b)(a^2 + ab + b^2) to be
prime we must have a - b = 1, so p must be a
difference of consecutive cubes.
"""
total = 0
for i in range(len(cube_list) - 1):
p_ = cube_list[i + 1] - cube_list[i]
#is strongly advised that you solve this one first.
from utils import Utils
u = Utils()
MAX = 200000
def get_exp(n, p):
i = 0
while n % p == 0:
i += 1
n = n / p
return i
prime_list = u.sieve(MAX)
#calculating the desired number using memoization, stopping
#as soon as we find it:
def p108():
i = 2
l = [0, 1]
while i < MAX:
for p in prime_list:
if i % p == 0:
val = l[i / p] + \
2 * l[i / (p ** get_exp(i, p))] - 1
if val >= 1000:
print i
return
else:
#coding: UTF-8
#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 < 10^8, have precisely two,
#not necessarily distinct, prime factors?
from utils import Utils
from math import sqrt
from bisect import bisect
u = Utils()
#One of the accepted solutions from the forum (by
#logopetria, @Sat, 22 Mar 2008, 08:45):
primes = u.sieve(5 * (10 ** 7))
def p187():
N=10**8
total=0
for x in range(bisect(primes, sqrt(N))):
p = primes[x]
total += bisect(primes, N/p) - x
print total
u.exec_time(p187)
