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 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_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