def challenge127(): maximum = 120000 primes = list(sievedPrimes(maximum)) rads = [1,] * maximum for prime in primes[1:]: for i in xrange(prime - 1, maximum, prime): rads[i] *= prime rad_lookup = [[r, i + 1] for i, r in enumerate(rads)] rad_lookup.sort() result = 0 for c in xrange(1, maximum + 1): for next in rad_lookup: a = next[1] if next[0] * rads[c - 1] >= c: break b = c - a if a < (c / 2) and next[0] * rads[b - 1] * rads[c - 1] < c and \ gcd(a, b) == 1: result += c return result
def challenge234(): # Get primes needed limit = 999966663333 primes = sievedPrimes(1000000) primes.next() current = primes.next() total = list() for next in primes: # square of current will definitely not be semidivisable lows = set(myrange(current**2 + current, next**2 if next**2 < limit + 1 else limit + 1, current)) highest = next**2 - next while highest > limit: highest -= next highs = set(myrange(highest, current**2, -next)) # Get numbers in one or other but not both valid = lows.symmetric_difference(highs) total.extend(list(valid)) current = next return sum(t for t in total if t < limit)
def challenge087(): limit = 50000000 # Get potential squares sqLimit = int(limit**0.5) primes = list(sievedPrimes(sqLimit)) primes.remove(1) sqPrimes = list([n**2 for n in primes]) # Get potential cubes cuLimit = int(limit**(1.0 / 3.0)) cuPrimes = list([n**3 for n in [n for n in primes if n <= cuLimit]]) # Get potential fourths foLimit = int(limit**(0.25)) foPrimes = list([n**4 for n in [n for n in primes if n <= foLimit]]) nAnswers = set() for s in sqPrimes: for c in cuPrimes: sc = s + c if sc >= limit: break for f in foPrimes: scf = sc + f if scf >= limit: break nAnswers.add(scf) return len(nAnswers)
def challenge131(): limit = 1000000 primes = list(sievedPrimes(limit)) # n**3 + n**2*p = m**3 # n**2 * (n + p) = m**3 # (n + p) = m**3 / n**2 # p = (m**3 - n**3) / n**2 # n is a cube, a**3 # Cubes where the difference between them is a multiple of n**2 found = 0 for p in primes: # Find two cubes that have a difference of p lowerCube = 1 upperCube = 2 while 1: diff = upperCube**3 - lowerCube**3 # print diff if diff > p: lowerCube += 1 if lowerCube == upperCube: # Couldn't find break elif diff < p: upperCube += 1 else: # Found found += 1 break return found
def working(limit): primes = list(sievedPrimes(limit))[1:] ans = list() for x in xrange(2, limit): s = sigma2(x, primes) if isSquare(s): print x ans.append(x) return ans
def challenge108(): target = 1000 primeLimit = 10000 primes = list(sievedPrimes(primeLimit))[1:] # # Get suitable primeIndices indices = primeIndices((target * 2 - 1), 0, primes, 0) return indices
def challenge123(): primes = list(sievedPrimes(250000)) limit = 10**10 for n in xrange(7038, len(primes), 2): p = primes[n] r = getRemainder(p, n) if r > limit: return n + 1 n += 1 return
def challenge214(): limit = 40000000 length = 25 primes = list(sievedPrimes(limit)) phis = totients(limit, primes[1:]) total = 0 for p in primes: if (p - 1) >= (2**(length - 2)): if totientChainLength(p, 0, length, phis): total += p return total
def semiprimes(n): primes = list(sievedPrimes(n // 2))[1:] nPrimes = len(primes) nTwos = 0 for i in xrange(nPrimes): for j in xrange(i, nPrimes): if primes[i] * primes[j] >= n: break nTwos += 1 return nTwos
def challenge130(): limit = 14702 # Optimised value primes = set(sievedPrimes(limit)) found = [] for n in [n for n in xrange(5, limit, 2) if (n % 5 != 0) and n not in primes]: if (n-1) % A(n) == 0: found.append(n) return sum(found)
def R(k): primes = sievedPrimes(160002) primes.next() primes.next() facts = list() for p in primes: if pow(10, k, 9*p) == 1: facts.append(p) if len(facts) == 40: break return facts
def challenge069(): limit = 1000000 sp = list(sievedPrimes(limit)) sp.remove(1) primes = dict([p, float(p) / (p - 1)] for p in sp) nPhi = [1.0] * limit for k, n in primes.items(): current = k - 1 while current < limit: nPhi[current] *= n current += k highest = max(nPhi) return nPhi.index(highest) + 1
def getNumTarget(limit): primes = sievedPrimes(limit) primes.next() primes.next() total = 2 for p in primes: if p % 4 == 3: total += 1 if (p * 4) < limit: total += 1 if (p * 16) < limit: total += 1 return total
def challenge060(): # primes = [1, 3, 7, 37, 73, 109, 673, 1093, 1097, 3109, 3673, 6733, 6737, 7109, 7673, 109673, 673109] primes = list(sievedPrimes(10000)) primes.remove(1) primes.remove(2) # Get all prime pairs that concatenate pairs = getPrimePairs(primes) # Generate prime numbers # answer = nextDigits([], 5, primes, 30000) answer = nextDigitsDict([], 5, pairs, 30000, set(pairs.keys())) if answer: answer = sum(answer) return answer
def challenge231(): n = 20000000 k = 15000000 # Get the primes needed primes = sievedPrimes(n) # Remove 1 primes.next() total = 0 # Cycle through primes for p in primes: current = 1 # Loop through indexes of p index = 1 while 1: current *= p # Get numerator range # Get first multiple on or after n - k # Get first multiple before n numRange = (getFirstMultipleOnOrAfter(n - k + 1, current), getFirstMultipleOnOrBefore(n, current)) # Get denominator range # Get first multiple on or after 1 # Get first multiple before k denRange = (getFirstMultipleOnOrAfter(1, current), getFirstMultipleOnOrBefore(k, current)) # Record if either is in range inRange = False # Check each is in range, # If in range then get the number of multiples in range # Multiply by p and add to sum if numRange[0] <= numRange[1]: total += numInRange(numRange[0], numRange[1], current) * p inRange = True if denRange[0] <= denRange[1]: total -= numInRange(denRange[0], denRange[1], current) * p inRange = True if not inRange: break return total
def challenge050(): limit = 1000000 primes = list(sievedPrimes(limit - 1)) knownPrimes = set(primes) del primes[0] nPrimes = len(primes) longest = 0 answer = 0 for start in xrange(0, nPrimes): for end in xrange(start + 1 + longest, nPrimes): total = sum(primes[start: end]) if total >= limit: break if total in knownPrimes: longest = end - start + 1 answer = total return answer
def challenge049(): permutationPrimes = dict() for prime in [n for n in sievedPrimes(9999) if n > 999]: chars = string.join(sorted(list(str(prime))), "") if permutationPrimes.has_key(chars): permutationPrimes[chars] += [prime] else: permutationPrimes[chars] = [prime] # Remove those less than 2 permutationPrimes = dict([(c, p) for c, p in permutationPrimes.iteritems() if len(p) > 2]) for primes in permutationPrimes.itervalues(): for p1 in primes: for p2 in [p for p in primes if p != p1]: diff = p2 - p1 p3 = p2 + diff if p3 in primes: return int(str(p1) + str(p2) + str(p3))
def challenge134(): limit = 10**6 primes = sievedPrimes(limit + (limit / 10)) # Strip pre 5 for r in xrange(3): primes.next() p1 = primes.next() S = 0 for p2 in primes: if p1 > limit: break # f(target, current, step) n = f(p1, p2, p2) S += n p1 = p2 return S
def totients(n, primes = None): # Get the primes if primes == None: primes = sievedPrimes(n) # Remove 1 primes.next() # Get result grid ans = range(n + 1) # Set each prime to prime - 1 for p in primes: # will only use even other than prime ans[p] = p - 1 # Step through ans in steps of p for t in xrange(2 * p, n + 1, p): # Set to current - (current // p) ans[t] -= (ans[t] // p) return ans
def challenge128(): primes = set(sievedPrimes(1000000)) # Loop through the layers layer = 2 current = 7 found = [1, 2] maximum = 2000 while len(found) < maximum: end = current + 6 * layer current += 1 # first if nPrimes(primes, [end - current, 6 * layer + 1, 6 * layer + (6 * (layer + 1)) - 1]) == 3: found.append(current) # end if nPrimes(primes, [end - current, 6 * layer + 6 * (layer - 1) - 1, 6 * (layer + 1) - 1]) == 3: found.append(end) current = end layer += 1 return found[maximum - 1]
def challenge027(): limit = 999 aMax = 0 bMax = 0 maximum = 1 bS = list(sievedPrimes(limit + 1)) for b in bS: for a in xrange(-b, limit + 1): n = 1 while True: f = n * (n + a) + b if not isPrime(f): break n += 1 if n > maximum: maximum = n aMax = a bMax = b return aMax * bMax
def challenge203(): rows = 51 nums = set() # Generate triangle row = [1] * rows while len(row) > 0: # Remove last row = row[:-1] for i in xrange(1, len(row)): row[i] += row[i - 1] nums.update(row) # Get maximum highest = max(nums) # Get primes up to root of highest primes = list([x**2 for x in sievedPrimes(int(highest**0.5) + 1)])[1:] squareFree = [] for n in nums: free = True for p in primes: if p > n: break if n%p == 0: free = False break if free: squareFree.append(n) return sum(squareFree)
def slowButRight(limit): primes = set(sievedPrimes(limit)) return [n for sq, n in ((squareSum(n), n) for n in xrange(limit, 0, -1) if n not in primes) if isSquare(sq)]
def challenge133(): limit = 50 divs = [prime for prime in list(sievedPrimes(100000))[1:] if not divs_repunit(prime, limit)] return sum(divs) + 3
def hamNums(maxPrime, limit): # generate primes without 1 primes = list(sievedPrimes(maxPrime))[1:] found = set() return getHams(1, limit, primes) + 1