def problem249():
primes = primesUpTo(5000)
sums = defaultdict(int)
sums[0] = 1
for p,total in runningTotal(primes):
for j in range(total,p-1,-1):
sums[j] = sums[j] + sums[j-p]
return sum([sums[k] for k in range(total+1) if isPrime(k)]) % 10**16
def problem77():
primes = primesUpTo(100)
for target in count(11):
ways = [1] + [0] * target
for prime in primes:
for j in range(prime, target + 1):
ways[j] += ways[j - prime]
if ways[target] > 5000:
return target
def problem134(): total = 0 primes = primesUpTo(1000100) for index, p1 in enumerate(primes): if p1 == 2 or p1 == 3: continue if p1 > 1000000: break p2 = primes[index+1] total += smallest(p1, p2) return total
def test_order_old(self):
self.assertEqual(order_old(2, 7), 3)
self.assertEqual(order_old(3, 50), 20)
from PE_primes import primesUpTo
from random import randint
# Verifying Fermat's little theorem
primes = primesUpTo(100)
for p in primes:
a = randint(1, p - 1)
self.assertEqual((p - 1) % order_old(a, p), 0)
def test_order(self):
self.assertEqual(order(2, 7), 3)
self.assertEqual(order(3, 50), 20)
from PE_primes import primesUpTo
from random import randint
# Verifying Fermat's little theorem
primes = primesUpTo(100)
for p in primes:
a = randint(1, p - 1)
self.assertEqual((p - 1) % order(a, p), 0)
def problem214():
total = 0
phi = computeAllPhi()
def lengthOfChain(n,_d={1:1}):
if n not in _d:
_d[n] = lengthOfChain(phi[n]) + 1
return _d[n]
for p in primesUpTo(40000000):
if lengthOfChain(p) == 25:
total += p
return total
def problem108():
def update(minimum, n=1, divs=1, index=0, power=50):
# Worst than what we found so far or used up all the primes
if n >= minimum or index >= len(primes):
return minimum
# We found n with enough divisors
if divs >= 2*(4*10**6):
return n
# the current prime we are looking at
p = primes[index]
# All the possible powers
for e in range(1, power+1):
minimum = min(minimum, update(minimum, n * p**e, divs * (2*e+1), index+1, e))
return minimum
primes = primesUpTo(50)
minimum = product(primes)
return update(minimum)
def problem200():
primes = primesUpTo(169249+2)
candidates = []
# Do not know why I can make this assumption
# There are other types of primeproof sqube but they
# are all much larger
for p in [2,5]:
for q in primes:
if q == 2 or q == 5: continue
candidates.append((p, q))
candidates.append((q, p))
candidates.sort(key=lambda x: x[0]**2 * x[1]**3)
found = 1
seen = {200}
for p, q in candidates:
if 2 in (p, q) or 5 in (p, q):
if isPrimeProofsqubeEven(p, q):
found += 1
else:
if isPrimeProofsqubeOdd(p, q):
found += 1
if found == 200:
return p ** 2 * q ** 3
return seen
def test_order(orderFunc):
primes = primesUpTo(10000)
for p in primes:
a = randint(1, p - 1)
orderFunc(a, p)
def test_containment(self):
from PE_primes import primesUpTo
m = Orderedlist(primesUpTo(1000))
self.assertTrue(101 in m)
self.assertRaises(ValueError, lambda x: x in m, 100)
def problem41a(): from projectEuler import isPandigital from PE_primes import primesUpTo # can avoid 8 digits and 9 digits as sum(1 + 2 + 3 + 4 + 5 + 6 + 7 + 8) is divisible by 3 and thus so is the numbers with 9 digits return max( p for p in primesUpTo(10**7) if isPandigital(p) )
def test_containment(self):
from PE_primes import primesUpTo
m = Orderedlist(primesUpTo(1000))
self.assertTrue(101 in m)
self.assertRaises(ValueError, lambda x: x in m, 100)
def problem204():
count = 1
for a in genProducts(10 ** 9, primesUpTo(100)):
count += 1
print(count)
def test_primesUpTo(self):
self.assertEqual(primesUpTo(10), (2, 3, 5, 7))
def test_primes(self):
primes = primesUpTo(10 ** 6)
for index, p in enumerate(iPrime()):
self.assertEqual(p, primes[index])
if index == len(primes) - 1:
break
def test_primesUpTo(self):
self.assertEqual(primesUpTo(10), (2, 3, 5, 7))
def test_primes(self):
primes = primesUpTo(10**6)
for index, p in enumerate(iPrime()):
self.assertEqual(p, primes[index])
if index == len(primes) - 1:
break
def problem266():
return PSR(primesUpTo(190)) % 10 ** 6
