def compute(): LIMIT = 150000000 INCREMENTS = [1, 3, 7, 9, 13, 27] # Must be in non-decreasing order NON_INCREMENTS = set(range(INCREMENTS[-1])) - set(INCREMENTS) maxnumber = LIMIT**2 + INCREMENTS[-1] primes = eulerlib.list_primes(eulerlib.sqrt(maxnumber)) def has_consecutive_primes(n): # Generate the set of numbers to test for primality n2 = n**2 temp = [(n2 + k) for k in INCREMENTS] # Test that each number is prime. # Note: The nesting of the loops can be reversed, but this way is much faster. if any((x != p and x % p == 0) for p in primes for x in temp): return False # Test that each number that is not an increment is composite. # This checks that the prime numbers we found are in fact consecutive. return all((not is_prime(n2 + k)) for k in NON_INCREMENTS) def is_prime(n): end = eulerlib.sqrt(n) for p in primes: if p > end: break if n % p == 0: return False return True ans = sum(n for n in range(0, LIMIT, 10) if has_consecutive_primes(n)) return str(ans)
def p010(): max_num = 1999999 res = sum(eulerlib.list_primes(max_num)) return res
def compute(): BASE = 10**14 SEARCH_RANGE = 10000000 # Number of candidates starting from BASE to search for primes. Hopefully there are 100 000 primes among here. MODULUS = 1234567891011 # iscomposite[i] pertains to the number BASE + i # Sieve of Eratosthenes, but starting at BASE iscomposite = [False] * SEARCH_RANGE primes = eulerlib.list_primes(eulerlib.sqrt(BASE + SEARCH_RANGE)) for p in primes: for i in range((BASE + p - 1) // p * p - BASE, len(iscomposite), p): iscomposite[i] = True # Returns p - BASE, where p is the next prime after n + BASE def next_prime(n): while True: n += 1 if n >= len(iscomposite): raise AssertionError("Search range exhausted") if not iscomposite[n]: return n ans = 0 p = 0 for i in range(100000): p = next_prime(p) ans = (ans + fibonacci_mod(BASE + p, MODULUS)) % MODULUS return str(ans)
def compute(): LIMIT = 10000000 possible = set() primes = eulerlib.list_primes(LIMIT // 2) end = eulerlib.sqrt(LIMIT) for i in range(len(primes)): p = primes[i] if p > end: break for j in range(i + 1, len(primes)): q = primes[j] lcm = p * q if lcm > LIMIT: break multlimit = LIMIT // lcm multiplier = 1 while multiplier * p <= multlimit: multiplier *= p maxmult = multiplier while multiplier % p == 0: multiplier //= p while multiplier * q <= multlimit: multiplier *= q maxmult = max(multiplier, maxmult) possible.add(maxmult * lcm) ans = sum(possible) return str(ans)
def compute(): DIGITS = 10 primes = eulerlib.list_primes(eulerlib.sqrt(10**DIGITS)) # Only valid if 1 < n <= 10^DIGITS. def is_prime(n): end = eulerlib.sqrt(n) for p in primes: if p > end: break if n % p == 0: return False return True ans = 0 # For each repeating digit for digit in range(10): # Search by the number of repetitions in decreasing order for rep in range(DIGITS, -1, -1): sum = 0 digits = [0] * DIGITS # Try all possibilities for filling the non-repeating digits for i in range(9**(DIGITS - rep)): # Build initial array. For example, if DIGITS=7, digit=5, rep=4, i=123, then the array will be filled with 5,5,5,5,1,4,7. for j in range(rep): digits[j] = digit temp = i for j in range(DIGITS - rep): d = temp % 9 if d >= digit: # Skip the repeating digit d += 1 if j > 0 and d > digits[ DIGITS - j]: # If this is true, then after sorting, the array will be in an already-tried configuration break digits[-1 - j] = d temp //= 9 else: digits.sort() # Start at lowest permutation while True: # Go through all permutations if digits[ 0] > 0: # Skip if the number has a leading zero, which means it has less than DIGIT digits num = int("".join(map(str, digits))) if is_prime(num): sum += num if not eulerlib.next_permutation(digits): break if sum > 0: # Primes found; skip all lesser repetitions ans += sum break return str(ans)
def compute(): DIGITS = 10 primes = eulerlib.list_primes(eulerlib.sqrt(10**DIGITS)) # Only valid if 1 < n <= 10^DIGITS. def is_prime(n): end = eulerlib.sqrt(n) for p in primes: if p > end: break if n % p == 0: return False return True ans = 0 # For each repeating digit for digit in range(10): # Search by the number of repetitions in decreasing order for rep in range(DIGITS, -1, -1): sum = 0 digits = [0] * DIGITS # Try all possibilities for filling the non-repeating digits for i in range(9**(DIGITS - rep)): # Build initial array. For example, if DIGITS=7, digit=5, rep=4, i=123, then the array will be filled with 5,5,5,5,1,4,7. for j in range(rep): digits[j] = digit temp = i for j in range(DIGITS - rep): d = temp % 9 if d >= digit: # Skip the repeating digit d += 1 if j > 0 and d > digits[DIGITS - j]: # If this is true, then after sorting, the array will be in an already-tried configuration break digits[-1 - j] = d temp //= 9 else: digits.sort() # Start at lowest permutation while True: # Go through all permutations if digits[0] > 0: # Skip if the number has a leading zero, which means it has less than DIGIT digits num = int("".join(map(str, digits))) if is_prime(num): sum += num if not eulerlib.next_permutation(digits): break if sum > 0: # Primes found; skip all lesser repetitions ans += sum break return str(ans)
def compute(): primes = eulerlib.list_primes(1000000) num = 0 for i in range(4, 1000000): if isFourPrimes(i, primes): num += 1 else: num = 0 if num == 4: print(i - 3) break
def compute(): LIMIT = 10**8 - 1 ans = 0 primes = eulerlib.list_primes(LIMIT // 2) sqrt = eulerlib.sqrt(LIMIT) for (i, p) in enumerate(primes): if p > sqrt: break end = binary_search(primes, LIMIT // p) ans += (end + 1 if end >= 0 else -end - 1) - i return str(ans)
def compute(): ans = 0 primes = eulerlib.list_primes(2000000) for i in itertools.count(2): p = primes[i] q = primes[i + 1] if p > 1000000: break k = 1 while k < p: k *= 10 m = (q - p) * reciprocal_mod(k % q, q) % q ans += m * k + p return str(ans)
def compute(): ans = 0 primes = eulerlib.list_primes(2000000) for i in itertools.count(2): p = primes[i] q = primes[i + 1] if p > 1000000: break k = 1 while k < p: k *= 10 m = (q - p) * eulerlib.reciprocal_mod(k % q, q) % q ans += m * k + p return str(ans)
def prime_factors(n): a = [] t = n if eulerlib.is_prime(t): return [t] for p in eulerlib.list_primes(t): while t % p == 0: t /= p a.append(p) if eulerlib.is_prime(t): a.append(t) break return a
def compute(): LIMIT = 10**9 primes = eulerlib.list_primes(100) def count(primeindex, product): if primeindex == len(primes): return 1 if product <= LIMIT else 0 else: result = 0 while product <= LIMIT: result += count(primeindex + 1, product) product *= primes[primeindex] return result return str(count(0, 1))
def compute(): LIMIT = 5000 MODULUS = 10**16 # Use dynamic programming. count[i] is the number of subsets of primes with the sum of i, modulo MODULUS. count = [0] * (LIMIT**2 // 2) count[0] = 1 s = 0 # Sum of all primes seen so far, and thus the highest index among nonzero entries in 'count' for p in eulerlib.list_primes(LIMIT): for i in range(s, -1, -1): count[i + p] = (count[i + p] + count[i]) % MODULUS s += p isprime = eulerlib.list_primality(len(count)) ans = sum(count[i] for i in range(len(count)) if isprime[i]) % MODULUS return str(ans)
def answer(): primes = eulerlib.list_primes(1000000) length = 0 max = 0 lastj = len(primes) for i in range(len(primes)): for j in range(i + length, lastj): result = sum(primes[i:j]) if (result < 1000000): if (result in primes): length = j - i max = result else: lastj = j + 1 break return max
def compute(): LIMIT = 50000000 primes = eulerlib.list_primes(eulerlib.sqrt(LIMIT)) sums = set([0]) for i in range(2, 5): newsums = set() for p in primes: q = p**i if q > LIMIT: break for x in sums: if x + q <= LIMIT: newsums.add(x + q) sums = newsums return str(len(sums))
def compute(): ans = 0 isprime = eulerlib.list_primality(999999) primes = eulerlib.list_primes(999999) consecutive = 0 for i in range(len(primes)): sum = primes[i] consec = 1 for j in range(i + 1, len(primes)): sum += primes[j] consec += 1 if sum >= len(isprime): break if isprime[sum] and consec > consecutive: ans = sum consecutive = consec return str(ans)
def compute(): primes = eulerlib.list_primes(1000000) isPrimes = eulerlib.list_primality(1000000) max = 0 maxConsecutive = 0 for i in range(len(primes)): sum = 0 length = 0 for j in range(i, len(primes)): sum += primes[j] length += 1 if sum > 1000000: break if isPrimes[sum]: if length > maxConsecutive: max = sum maxConsecutive = length print(max)
def compute(): # Collect unique numbers in Pascal's triangle numbers = set(eulerlib.binomial(n, k) for n in range(51) for k in range(n + 1)) maximum = max(numbers) # Prepare list of squared primes primes = eulerlib.list_primes(eulerlib.sqrt(maximum)) primessquared = [p * p for p in primes] def is_squarefree(n): for p2 in primessquared: if p2 > n: break if n % p2 == 0: return False return True # Sum up the squarefree numbers ans = sum(n for n in numbers if is_squarefree(n)) return str(ans)
def compute(): primes = eulerlib.list_primes(100000) ans = sum(p for p in primes if p == 2 or p == 5 or not has_divisible_repunit(p)) return str(ans)
import eulerlib ans = sum(eulerlib.list_primes(20)) print(ans)
def compute(): PRIME_LIMIT = 100000 # Arbitrary initial cutoff primes = eulerlib.list_primes(PRIME_LIMIT) # Tries to find any suitable set and return its sum, or None if none is found. # A set is suitable if it contains only primes, its size is targetsize, # its sum is less than or equal to sumlimit, and each pair concatenates to a prime. # 'prefix' is an array of ascending indices into the 'primes' array, # which describes the set found so far. # The function blindly assumes that each pair of primes in 'prefix' concatenates to a prime. # # For example, find_set_sum([1, 3, 28], 5, 10000) means "find the sum of any set # where the set has size 5, consists of primes with the lowest elements being [3, 7, 109], # has sum 10000 or less, and has each pair concatenating to form a prime". def find_set_sum(prefix, targetsize, sumlimit): if len(prefix) == targetsize: return sum(primes[i] for i in prefix) else: istart = 0 if (len(prefix) == 0) else (prefix[-1] + 1) for i in range(istart, len(primes)): if primes[i] > sumlimit: break if all((is_concat_prime(i, j) and is_concat_prime(j, i)) for j in prefix): prefix.append(i) result = find_set_sum(prefix, targetsize, sumlimit - primes[i]) prefix.pop() if result is not None: return result return None # Tests whether concat(primes[x], primes[y]) is a prime number, with memoization. @eulerlib.memoize def is_concat_prime(x, y): return is_prime(int(str(primes[x]) + str(primes[y]))) # Tests whether the given integer is prime. The implementation performs trial division, # first using the list of primes named 'primes', then switching to simple incrementation. # This requires the last number in 'primes' (if any) to be an odd number. def is_prime(x): if x < 0: raise ValueError() elif x in (0, 1): return False else: end = eulerlib.sqrt(x) for p in primes: if p > end: break if x % p == 0: return False for i in range(primes[-1] + 2, end + 1, 2): if x % i == 0: return False return True sumlimit = PRIME_LIMIT while True: setsum = find_set_sum([], 5, sumlimit - 1) if setsum is None: # No smaller sum found return str(sumlimit) sumlimit = setsum
def compute(): ans = sum(eulerlib.list_primes(1999999)) return str(ans)
import eulerlib LIMIT = 50000000 primes = eulerlib.list_primes(eulerlib.sqrt(LIMIT)) sums = {0} for i in range(2, 5): newsums = set() for p in primes: q = p**i if q > LIMIT: break for x in sums: if x + q <= LIMIT: newsums.add(x + q) sums = newsums print(str(len(sums)))
def compute(): primes = eulerlib.list_primes(1000000) for n in range(5, len(primes), 2): rem = n * primes[n - 1] * 2 if rem > 10000000000: return str(n)