def eightDivisorCount(n):
ps = Primes.MakePrimeList(int(n**0.5)+2)
primePi = Primes.Prime_Pi()
f = 0
for p in ps:
if p**7 > n:
break
#print p
f += 1
for p in ps:
if 2*p**3 > n:
break
f += primePi(n//(p**3), ps)
print p,f,len(primePi.restricted_memo)
if (n//(p**3)) >= p:
f -= 1
#print p, primePi(n//(p**3), ps)
for n1,p1 in enumerate(ps):
if p1**3 >= n:
break
for p2 in ps[n1+1:]:
if p1*p2*p2 >= n:
break
f += primePi(n//(p1*p2),ps) - primePi(p2,ps)
#print p1,p2,primePi(n//(p1*p2),ps),primePi(p2,ps)
if p2 < 10000:
print p1,p2,f,len(primePi.restricted_memo)
print p1,f,len(primePi.restricted_memo)
return f
def primeFrogProbability(N, croak_string):
ps = Primes.MakePrimeList(N)
ans = Fraction(0)
memo = {}
for position in range(1, N + 1):
ans += calcCroakProbability(N, position, croak_string, ps, memo)
return ans / N
def Program(nMax=100, GRAPHICS=False):
primes = Primes.MakePrimeList(nMax)
primeGraph = Networks.UndirectedGraph()
for p in primes:
primeGraph.AddNode(p)
for p2 in primeGraph.GetNodes():
if Primes.isPrime(concatenateIntegers(p, p2), primes):
if Primes.isPrime(concatenateIntegers(p2, p), primes):
primeGraph.AddEdge(p, p2)
for p1 in primes:
possibles = primeGraph.GetNeighbors(p1)
for p2 in possibles:
possibles2 = listIntersection(possibles,
primeGraph.GetNeighbors(p2))
for p3 in possibles2:
possibles3 = listIntersection(possibles2,
primeGraph.GetNeighbors(p3))
for p4 in possibles3:
possibles4 = listIntersection(possibles3,
primeGraph.GetNeighbors(p4))
for p5 in possibles4:
print(p1, p2, p3, p4, p5), p1 + p2 + p3 + p4 + p5
if GRAPHICS:
NetGraphics.DisplayCircleGraph(primeGraph)
return primeGraph
def Euler118_2():
primes = Primes.MakePrimeList(100000000)
print 'Primes Calculated'
primes = [p for p in primes if not repeats_digits(p)]
print 'Primes with repeated digits eliminated'
num_sets = build_sets(0,[], primes)
print 'Number of Pandigital Prime Sets: '+str(num_sets)
return num_sets
def Euler484a(N):
start = time.clock()
p_max = int(sp.sqrt(N) + 1000)
primes = Primes.MakePrimeList(p_max)
print 'Primes up to %d calculated. %d primes' % (p_max, len(primes))
ans = F(N, 0, primes)
end = time.clock()
print '%f seconds' % (end - start, )
return ans
def Euler118_1():
permutes = itertools.permutations([1,2,3,4,5,6,7,8,9])
primes = Primes.MakePrimeList(10000)
prime_sets = set()
for digit_list in permutes:
find_prime_sets(digit_list, set(), prime_sets, primes)
print 'Number of Pandigital Prime Sets: '+str(len(prime_sets))
return prime_sets
def old_432(m):
primes = Primes.MakePrimeList(int(m * 2))
ans = sum_range(1, 18)
ans += weird_sum_tot(m, 7, primes)
ans *= 510510
for ix in range(7):
ans *= (primes[ix] - 1)
ans /= primes[ix]
return ans
def new_432(m):
#primes = Primes.MakePrimeList(int(1.2*m**(1./2))+100)
primes = Primes.MakePrimeList(int(1.2 * m**(1. / 2)) + 120)
prime_pi = Primes.Prime_Pi()
ans = sum_range(1, 18) + func(m, 7, primes, prime_pi)
ans *= 510510
for ix in range(7):
ans *= (primes[ix] - 1)
ans /= primes[ix]
return ans
def Euler77(numWays):
"""
Finds the first number that can be partitioned into primes in numWays.
"""
primeList = Primes.MakePrimeList(max(numWays, 100))
partialPrimeMemo = {}
n = 2
while primePartition(n, primeList, partialPrimeMemo) < numWays:
n += 1
return n
def Euler231(n, m):
""" n choose m
"""
pList = Primes.MakePrimeList(n + 1)
summ = 0
for p in pList:
summ += p * (Number_Ps_in_N_factorial(n, p) - Number_Ps_in_N_factorial(
m, p) - Number_Ps_in_N_factorial(n - m, p))
return summ
def Euler131(N):
primes = Primes.MakePrimeList(int(sp.sqrt(N))+4)
x = 1
p = 3*x*x+3*x+1
count = 0
while p <= N:
if Primes.isPrime(p, primes):
count += 1
x += 1
p = 3*x*x + 3*x + 1
return count
def calc_mobius(n):
primes = Primes.MakePrimeList(n)
mu = [1]*(n+1)
mu[0] = 0
mu[1] = 1
for p in primes:
mu[p] = -1
i = 2
while p * i <= n:
mu[p*i] *= -1
i += 1
i = 1
while p*p*i <= n:
mu[p*p*i] = 0
i += 1
return mu
def Euler268(N, M=100):
primes = Primes.MakePrimeList(M)
#return f(primes, 4, N)
added = [0] * (len(primes) + 1)
ans = 0
for r in range(4, len(primes) + 1):
print N, r, ans
if prod(primes[:r]) > N:
break
multiplier = 1 - added[r]
# Update how many times we have added numbers divisible by
# exactly x primes in the list.
for x in range(r, len(primes) + 1):
added[x] += multiplier * comb(x, r, True)
# Actually add them
ans += multiplier * sum(N // prod(c) for c in combinations(primes, r))
return ans
def Euler351(N):
M = N / 2
primes = Primes.MakePrimeList(M)
ans = 0
r = 1
while r < len(primes) and prod(primes[:r]) <= M:
sign = int((-1)**(r + 1))
count = 0
for c in combProdLessThan(primes, r, M):
count += 1
x = prod(c)
p = int(N // x)
q = int(N // (2 * x))
ans += sign * (p * q - q * (q + 1))
print '%d from list of len %d: %d times; \ttotal %d' % (r, len(primes),
count, ans)
r += 1
return 6 * (2 * ans + M + N - 2)
def Euler122():
primes = Primes.MakePrimeList(200)
m = {}
m[1] = 0
for x in range(2, 201):
if x in primes:
m[x] = m[x - 1] + 1
else:
m[x] = 0
y = x
for p in primes:
while y % p == 0 and y > 0:
m[x] += m[p]
ans = 0
for x in range(1, 201):
ans += m[x]
print 'Sum: ', ans
return ans
def Euler193(N):
'''
Calculates the number of squarefree numbers less than N
'''
root = round(sp.sqrt(N))
primes = Primes.MakePrimeList(root)
num = 0
n = 1
min_prod = 2
#---------------------------------------#
# Loop over the number of primes to use #
# in the inclusion-exclusion principle. #
#---------------------------------------#
while min_prod <= root:
#-----------------------------------------#
# Iterate over all the combinations of n #
# primes, adding or subtracting according #
# to the inclusion-exclusion principle. #
#-----------------------------------------#
ix_list = range(n)
done = False
while not done:
# Calculate the number of square including numbers
p = sp.product([primes[ix]*primes[ix] for ix in ix_list])
#print [primes[i] for i in ix_list]
if n % 2 == 0:
num -= (N-1) / p
#print '-'+str(N / p)
else:
num += (N-1) / p
#print '+'+str(N/p)
done = not ix_combo(ix_list, primes, root)
n += 1
min_prod = sp.product(primes[:n])
num = N - num - 1
#print 'Number of squarefree numbers below '+str(N)+': '+str(num)
return num
def Euler122(N):
primes = Primes.MakePrimeList(N+2)
m = {}
m[1] = 0
for x in range(2, N+1):
if x in primes:
#print x, m[x-1]
m[x] = m[x-1] + 1
else:
m[x] = 0
y = x+0
for p in primes:
while y%p == 0 and y > 0:
m[x] += m[p]
y /= p
ans = 0
for x in range(1, N+1):
ans += m[x]
print 'Sum: ', ans
print m
return ans
def Euler87(n):
ps = Primes.MakePrimeList(int(scipy.sqrt(n))*2)
nF = 0
nums = []
count = 0
while ps[nF]**4 <= n:
nC = 0
while ps[nF]**4 + ps[nC]**3 <= n:
nS = 0
while ps[nF]**4 + ps[nC]**3 + ps[nS]**2 <= n:
a = ps[nF]**4 + ps[nC]**3 + ps[nS]**2
count += 1
nums.append(a)
nS += 1
nC += 1
nF += 1
nums.sort()
for x in range(1,len(nums)):
if nums[x]==nums[x-1]:
count -= 1
return count
def Euler484(N):
rt = int(sp.sqrt(N) + 0.0001)
primes = Primes.MakePrimeList(rt)
mobius = make_mobius(rt, primes)
marten = make_marten(mobius)
d_fact = make_dfact(rt, primes)
marten_mem = {}
def Marten(n):
if n < len(marten):
return marten[n]
try:
return marten_mem[n]
except KeyError:
pass
ans = 1
r = int(sp.sqrt(n) + 0.0001)
for g in range(2, r + 1):
ans -= Marten(n // g)
for z in range(1, r):
ans += ((n // z) - (n // (z + 1))) * Marten(z)
if n // r != r:
ans += ((n // r) - (n // (r + 1))) * Marten(r)
marten_mem[n] = ans
return ans
def sqf(n):
ans = n
r = int(sp.sqrt(n) + 0.0001)
for d in range(2, r + 1):
ans += mobius[d] * (n // (d * d))
return ans
def F(n):
if n == 1:
return 1
ans = sqf(n)
r = int(sp.sqrt(n) + 0.0001)
for d in range(2, r + 1):
if mobius[d] != 0:
c = list(d_fact[d])
ans -= mobius[d] * F1(c, [2] * len(c), n // (d * d))
return ans
def F1(p, r, n):
if n == 0:
return 0
if not p:
return F(n)
p0 = p.pop(0)
r0 = r.pop(0)
if p0 == 2 and r0 == 2:
return 4 * F1(p, r, n)
pn = p[:]
rn = r[:]
pn.insert(0, p0)
rn.insert(0, 1)
ans = f(p0, r0) * F1(p, r, n)
n /= p0
s = 0
while n > 0:
ans -= f(p0, r0 + s) * F1(pn, rn, n)
ans += f(p0, r0 + s + 1) * F1(p, r, n)
n /= p0
s += 1
return ans
def f(p, r):
if r % p == 0:
return p**r
return p**(r - 1)
return F(N), sqf, F, F1
def Euler193_slow(N):
primes = Primes.MakePrimeList(round(sp.sqrt(N)))
x = range(N)
for p in primes:
x = [i for i in x if i%(p**2) != 0]
return len(x)
r += n / d
d *= p
return r
def pow_mod(base, exp, mod):
if exp == 0:
return 1
if exp == 1:
return base % mod
x = pow_mod(base, exp / 2, mod)
if exp % 2 == 0:
return (x * x) % mod
else:
return (((x * x) % mod) * base) % mod
MOD = 1000000009
n = 10**5
p_list = Primes.MakePrimeList(n)
print 'Primes Built',
print ' '
r_list = [get_r(p, n) for p in p_list]
print 'Exponents Built'
ans = 1
for i in range(len(p_list)):
ans *= (pow_mod(p_list[i], 2 * r_list[i], MOD) + 1)
ans %= MOD
print 'S(' + str(n) + '!) = ', ans
def __init__(self, limit):
self.primes = Primes.MakePrimeList(int(sp.sqrt(2*limit)))
self.memo = {}
