def compute():
ans = 0
for i in range(100):
if eulerlib.sqrt(i) ** 2 != i:
temp = eulerlib.sqrt(i * 10 ** 200)
ans += sum(int(c) for c in str(temp)[: 100])
return str(ans)
def compute(): DIGITS = 100 MULTIPLIER = 100**DIGITS ans = sum( sum(int(c) for c in str(eulerlib.sqrt(i * MULTIPLIER))[ : DIGITS]) for i in range(100) if eulerlib.sqrt(i)**2 != i) return str(ans)
def compute(): TARGET = 2000000 end = eulerlib.sqrt(TARGET) + 1 gen = ((w, h) for w in range(1, end) for h in range(1, end)) func = lambda wh: abs(num_rectangles(wh[0], wh[1]) - TARGET) ans = min(gen, key=func) return str(ans[0] * ans[1])
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 list_sigma2(n):
# If i has a prime factor p <= sqrt, then quasiprimefactor[i] = p.
# Otherwise i > sqrt must be prime, and quasiprimefactor[i] = 0 because i may overflow an int16.
sqrt = eulerlib.sqrt(n)
quasiprimefactor = array.array("H", (0 for _ in range(n + 1)))
# Richer version of the sieve of Eratosthenes
for i in range(2, sqrt + 1):
if quasiprimefactor[i] == 0:
quasiprimefactor[i] = i
for j in range(i * i, n + 1, i):
if quasiprimefactor[j] == 0:
quasiprimefactor[j] = i
if sys.version_info.major < 3:
sigma2 = [0] * (n + 1)
else:
sigma2 = array.array("Q", (0 for _ in range(n + 1)))
sigma2[1] = 1
for i in range(2, len(sigma2)):
p = quasiprimefactor[i]
if p == 0:
p = i
sum = 1
j = i
p2 = p * p
k = p2
while j % p == 0:
sum += k
j //= p
k *= p2
sigma2[i] = sum * sigma2[j]
return sigma2
def compute():
LENGTH = 20
BASE = 10
MODULUS = 10 ** 9
# Maximum possible squared digit sum (for 99...99)
MAX_SQR_DIGIT_SUM = (BASE - 1) ** 2 * LENGTH
# sqsum[n][s] is the sum of all length-n numbers with a square digit sum of s, modulo MODULUS
# count[n][s] is the count of all length-n numbers with a square digit sum of s, modulo MODULUS
sqsum = []
count = []
for i in range(LENGTH + 1):
sqsum.append([0] * (MAX_SQR_DIGIT_SUM + 1))
count.append([0] * (MAX_SQR_DIGIT_SUM + 1))
if i == 0:
count[0][0] = 1
else:
for j in range(BASE):
for k in itertools.count():
index = k + j ** 2
if index > MAX_SQR_DIGIT_SUM:
break
sqsum[i][index] = (sqsum[i][index] + sqsum[i - 1][k] + pow(BASE, i - 1, MODULUS) * j * count[i - 1][
k]) % MODULUS
count[i][index] = (count[i][index] + count[i - 1][k]) % MODULUS
ans = sum(sqsum[LENGTH][i ** 2] for i in range(1, eulerlib.sqrt(MAX_SQR_DIGIT_SUM)))
return "{:09d}".format(ans % MODULUS)
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 = 1500000 # # Pythagorean triples theorem: # Every primitive Pythagorean triple with a odd and b even can be expressed as # a = st, b = (s^2-t^2)/2, c = (s^2+t^2)/2, where s > t > 0 are coprime odd integers. # triples = set() for s in range(3, eulerlib.sqrt(LIMIT) + 1, 2): for t in range(s - 2, 0, -2): if fractions.gcd(s, t) == 1: a = s * t b = (s * s - t * t) // 2 c = (s * s + t * t) // 2 if a + b + c <= LIMIT: triples.add((a, b, c)) ways = [0] * (LIMIT + 1) for triple in triples: sigma = sum(triple) for i in range(sigma, len(ways), sigma): ways[i] += 1 ans = ways.count(1) return str(ans)
def is_prime(n): end = eulerlib.sqrt(n) for p in primes: if p > end: break if n % p == 0: return False return True
def has_pandigital_product(n):
# Find and examine all factors of n
for i in range(1, eulerlib.sqrt(n) + 1):
if n % i == 0:
temp = str(n) + str(i) + str(n // i)
if "".join(sorted(temp)) == "123456789":
return True
return False
def floor(self): temp = eulerlib.sqrt(self.b * self.b * self.d) if self.b < 0: temp = -(temp + 1) temp += self.a if temp < 0: temp -= self.c - 1 return temp // self.c
def totient(n):
assert n > 0
p = 1
i = 2
end = eulerlib.sqrt(n)
while i <= end:
if n % i == 0: # Found a factor
p *= i - 1
n //= i
while n % i == 0:
p *= i
n //= i
end = eulerlib.sqrt(n)
i += 1
if n != 1:
p *= n - 1
return p
def num_divisors(n): end = eulerlib.sqrt(n) result = sum(2 for i in range(1, end + 1) if n % i == 0) if end**2 == n: result -= 1 return result
def num_divisors(x):
result = 0
k = eulerlib.sqrt(x)
for i in range(1, k + 1):
if x % i == 0:
result += 2
if k**2 == x:
result -= 1
return result
def num_divisors(n): result = 0 end = eulerlib.sqrt(n) for i in range(1, end + 1): if n % i == 0: result += 2 if end**2 == n: result -= 1 return result
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 count_divisors_squared(n):
count = 1
end = eulerlib.sqrt(n)
for i in itertools.count(2):
if i > end:
break
if n % i == 0:
j = 0
while True:
n //= i
j += 1
if n % i != 0:
break
count *= j * 2 + 1
end = eulerlib.sqrt(n)
if n != 1: # Remaining largest prime factor
count *= 3
return count
def count_divisors_squared(n): count = 1 end = eulerlib.sqrt(n) for i in itertools.count(2): if i > end: break if n % i == 0: j = 0 while True: n //= i j += 1 if n % i != 0: break count *= j * 2 + 1 end = eulerlib.sqrt(n) if n != 1: # Remaining largest prime factor count *= 3 return count
def num_divisors(x):
result = 0
k = eulerlib.sqrt(x)
for i in range(1, k + 1):
if x % i == 0:
result += 2
if k ** 2 == x:
result -= 1
return result
def pan(n):
# поиск всех факторов n
for i in range(1, eulerlib.sqrt(n) + 1):
if n % i == 0:
temp = str(n) + str(i) + str(n // i)
if "".join(sorted(temp)) == "123456789":
return True
return False
print(calc())
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():
TARGET = 2000000
bestdiff = None
end = eulerlib.sqrt(TARGET) + 1
for w in range(1, end):
for h in range(1, end):
diff = abs(num_rectangles(w, h) - TARGET)
if bestdiff is None or diff < bestdiff:
ans = w * h
bestdiff = diff
return str(ans)
def compute(): TARGET = 2000000 bestdiff = None end = eulerlib.sqrt(TARGET) + 1 for w in range(1, end): for h in range(1, end): diff = abs(num_rectangles(w, h) - TARGET) if bestdiff is None or diff < bestdiff: ans = w * h bestdiff = diff return str(ans)
def list_smallest_prime_factors(n): result = [None] * (n + 1) limit = eulerlib.sqrt(n) for i in range(2, len(result)): if result[i] is None: result[i] = i if i <= limit: for j in range(i * i, n + 1, i): if result[j] is None: result[j] = i return result
def list_smallest_prime_factors(n): result = [None] * (n + 1) limit = eulerlib.sqrt(n) for i in range(2, len(result)): if result[i] is None: result[i] = i if i <= limit: for j in range(i * i, n + 1, i): if result[j] is None: result[j] = i return result
def count_distinct_prime_factors(n): count = 0 while n > 1: count += 1 for i in range(2, eulerlib.sqrt(n) + 1): if n % i == 0: while True: n //= i if n % i != 0: break break else: break # n is prime return count
def compute():
# Finds any sum s = x+y+z such that s < limit, 0 < z < y < x, and these are
# perfect squares: x+y, x-y, x+z, x-z, y+z, y-z. Returns -1 if none is found.
#
# Suppose we let x + y = a^2 and x - y = b^2, so that they are always square.
# Then x = (a^2 + b^2) / 2 and y = (a^2 - b^2) / 2. By ensuring a > b > 0, we have x > y > 0.
# Now z < y and z < limit - x - y. Let y + z = c^2, then explicitly check
# if x+z, x-z, and y-z are square.
def find_sum(limit):
for a in itertools.count(1):
if a * a >= limit:
break
for b in reversed(range(1, a)):
if (
a + b
) % 2 != 0: # Need them to be both odd or both even so that we get integers for x and y
continue
x = (a * a + b * b) // 2
y = (a * a - b * b) // 2
if x + y + 1 >= limit: # Because z >= 1
continue
zlimit = min(y, limit - x - y)
for c in itertools.count(eulerlib.sqrt(y) + 1):
z = c * c - y
if z >= zlimit:
break
if issquare[x + z] and issquare[x - z] and issquare[y - z]:
return x + y + z
return None
sumlimit = 10
# Raise the limit until a sum is found
while True:
issquare = [False] * sumlimit
for i in range(eulerlib.sqrt(len(issquare) - 1) + 1):
issquare[i * i] = True
sum = find_sum(sumlimit)
if sum is not None:
sum = sumlimit
break
sumlimit *= 10
# Lower the limit until now sum is found
while True:
sum = find_sum(sumlimit)
if sum is None: # No smaller sum found
return str(sumlimit)
sumlimit = sum
def count_distinct_prime_factors(n):
count = 0
while n > 1:
count += 1
for i in range(2, eulerlib.sqrt(n) + 1):
if n % i == 0:
while True:
n //= i
if n % i != 0:
break
break
else:
break # n is prime
return count
def compute(): # Finds any sum s = x+y+z such that s < limit, 0 < z < y < x, and these are # perfect squares: x+y, x-y, x+z, x-z, y+z, y-z. Returns -1 if none is found. # # Suppose we let x + y = a^2 and x - y = b^2, so that they are always square. # Then x = (a^2 + b^2) / 2 and y = (a^2 - b^2) / 2. By ensuring a > b > 0, we have x > y > 0. # Now z < y and z < limit - x - y. Let y + z = c^2, then explicitly check # if x+z, x-z, and y-z are square. def find_sum(limit): for a in itertools.count(1): if a * a >= limit: break for b in reversed(range(1, a)): if (a + b) % 2 != 0: # Need them to be both odd or both even so that we get integers for x and y continue x = (a * a + b * b) // 2 y = (a * a - b * b) // 2 if x + y + 1 >= limit: # Because z >= 1 continue zlimit = min(y, limit - x - y) for c in itertools.count(eulerlib.sqrt(y) + 1): z = c * c - y if z >= zlimit: break if issquare[x + z] and issquare[x - z] and issquare[y - z]: return x + y + z return None sumlimit = 10 # Raise the limit until a sum is found while True: issquare = [False] * sumlimit for i in range(eulerlib.sqrt(len(issquare) - 1) + 1): issquare[i * i] = True sum = find_sum(sumlimit) if sum is not None: sum = sumlimit break sumlimit *= 10 # Lower the limit until now sum is found while True: sum = find_sum(sumlimit) if sum is None: # No smaller sum found return str(sumlimit) sumlimit = sum
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 count_distinct_prime_factors(n):
if n not in distinctprimefactorscache:
count = 0
x = n
while x > 1:
count += 1
for i in range(2, eulerlib.sqrt(x) + 1):
if x % i == 0:
x //= i
while x % i == 0:
x //= i
break
else:
break # x is prime
distinctprimefactorscache[n] = count
return distinctprimefactorscache[n]
def compute(): LIMIT = 10**15 MODULUS = 10**9 # Can be any number from 1 to LIMIT, but somewhere near sqrt(LIMIT) is preferred splitcount = eulerlib.sqrt(LIMIT) # Consider divisors individually up and including this number splitat = LIMIT // (splitcount + 1) # The sum (s+1)^2 + (s+2)^2 + ... + (e-1)^2 + e^2. def sum_squares(s, e): return (e * (e + 1) * (e * 2 + 1) - s * (s + 1) * (s * 2 + 1)) // 6 ans = sum((i * i * (LIMIT // i)) for i in range(1, splitat + 1)) ans += sum((sum_squares(LIMIT // (i + 1), LIMIT // i) * i) for i in range(1, splitcount + 1)) return str(ans % MODULUS)
def count_distinct_prime_factors(n): if n not in distinctprimefactorscache: count = 0 x = n while x > 1: count += 1 for i in range(2, eulerlib.sqrt(x) + 1): if x % i == 0: x //= i while x % i == 0: x //= i break else: break # x is prime distinctprimefactorscache[n] = count return distinctprimefactorscache[n]
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
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
def compute():
x0 = 3
y0 = 1
x = x0
y = y0
while True:
sqrt = eulerlib.sqrt(y**2 * 8 + 1)
if sqrt % 2 == 1: # Is odd
blue = (sqrt + 1) // 2 + y
if blue + y > 10**12:
return str(blue)
nextx = x * x0 + y * y0 * 8
nexty = x * y0 + y * x0
x = nextx
y = nexty
def compute(): LIMIT = 100000000 # Pythagorean triples theorem: # Every primitive Pythagorean triple with a odd and b even can be expressed as # a = st, b = (s^2-t^2)/2, c = (s^2+t^2)/2, where s > t > 0 are coprime odd integers. ans = 0 for s in range(3, eulerlib.sqrt(LIMIT * 2), 2): for t in range(1, s, 2): a = s * t b = (s * s - t * t) // 2 c = (s * s + t * t) // 2 p = a + b + c if p >= LIMIT: break if c % (a - b) == 0 and fractions.gcd(s, t) == 1: ans += (LIMIT - 1) // p return str(ans)
def compute():
LIMIT = 100000000
# Pythagorean triples theorem:
# Every primitive Pythagorean triple with a odd and b even can be expressed as
# a = st, b = (s^2-t^2)/2, c = (s^2+t^2)/2, where s > t > 0 are coprime odd integers.
ans = 0
for s in range(3, eulerlib.sqrt(LIMIT * 2), 2):
for t in range(1, s, 2):
a = s * t
b = (s * s - t * t) // 2
c = (s * s + t * t) // 2
p = a + b + c
if p >= LIMIT:
break
if c % (a - b) == 0 and fractions.gcd(s, t) == 1:
ans += (LIMIT - 1) // p
return str(ans)
def find_sum(limit): for a in itertools.count(1): if a * a >= limit: break for b in reversed(range(1, a)): if (a + b) % 2 != 0: # Need them to be both odd or both even so that we get integers for x and y continue x = (a * a + b * b) // 2 y = (a * a - b * b) // 2 if x + y + 1 >= limit: # Because z >= 1 continue zlimit = min(y, limit - x - y) for c in itertools.count(eulerlib.sqrt(y) + 1): z = c * c - y if z >= zlimit: break if issquare[x + z] and issquare[x - z] and issquare[y - z]: return x + y + z return None
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(): # 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():
LIMIT = 20000000
# Build table of smallest prime factors
smallestprimefactor = array.array("L", itertools.repeat(0, LIMIT + 1))
end = eulerlib.sqrt(len(smallestprimefactor) - 1)
for i in range(2, len(smallestprimefactor)):
if smallestprimefactor[i] == 0:
smallestprimefactor[i] = i
if i <= end:
for j in range(i * i, len(smallestprimefactor), i):
if smallestprimefactor[j] == 0:
smallestprimefactor[j] = i
# Returns all the solutions (in ascending order) such that
# for each k, 1 <= k < n and k^2 = 1 mod n.
def get_solutions(n):
if smallestprimefactor[n] == n: # n is prime
return (1, n - 1)
else:
temp = []
p = smallestprimefactor[n]
sols = solutions[n // p]
for i in range(0, n, n // p):
for j in sols:
k = i + j
if k * k % n == 1:
temp.append(k)
return tuple(temp)
# Process every integer in range
solutions = [(), (), (1,)]
ans = 0
for i in range(3, LIMIT + 1):
sols = get_solutions(i)
if i <= LIMIT // 2:
solutions.append(sols)
ans += sols[-2] # Second-largest solution
return str(ans)
def try_search(limit):
ways = {}
i = 2
while True:
cube = i**3
if cube >= limit:
break
for j in range(2, eulerlib.sqrt(limit - 1 - cube) + 1):
index = cube + j**2
ways[index] = ways.get(index, 0) + 1
i += 1
result = 0
count = 0
for i in sorted(ways.keys()):
if ways[i] == TARGET_WAYS and is_palindrome(i):
result += i
count += 1
if count == TARGET_COUNT:
return result
return None
def compute():
# Fundamental solution
x0 = 3
y0 = 1
# Current solution
x = x0
y = y0 # An alias for the number of red discs
while True:
# Check if this solution is acceptable
sqrt = eulerlib.sqrt(y**2 * 8 + 1)
if sqrt % 2 == 1: # Is odd
blue = (sqrt + 1) // 2 + y
if blue + y > 10**12:
return str(blue)
# Create the next bigger solution
nextx = x * x0 + y * y0 * 8
nexty = x * y0 + y * x0
x = nextx
y = nexty
def compute():
LIMIT = 20000000
# Build table of smallest prime factors
smallestprimefactor = array.array("L", itertools.repeat(0, LIMIT + 1))
end = eulerlib.sqrt(len(smallestprimefactor) - 1)
for i in range(2, len(smallestprimefactor)):
if smallestprimefactor[i] == 0:
smallestprimefactor[i] = i
if i <= end:
for j in range(i * i, len(smallestprimefactor), i):
if smallestprimefactor[j] == 0:
smallestprimefactor[j] = i
# Returns all the solutions (in ascending order) such that
# for each k, 1 <= k < n and k^2 = 1 mod n.
def get_solutions(n):
if smallestprimefactor[n] == n: # n is prime
return (1, n - 1)
else:
temp = []
p = smallestprimefactor[n]
sols = solutions[n // p]
for i in range(0, n, n // p):
for j in sols:
k = i + j
if k * k % n == 1:
temp.append(k)
return tuple(temp)
# Process every integer in range
solutions = [(), (), (1, )]
ans = 0
for i in range(3, LIMIT + 1):
sols = get_solutions(i)
if i <= LIMIT // 2:
solutions.append(sols)
ans += sols[-2] # Second-largest solution
return str(ans)
def try_search(limit):
# If i can be expressed as the sum of a square greater than 1 and
# a cube greater than 1, then ways[i] is the number of different ways
# it can be done. Otherwise, i is not a key in the ways dictionary.
ways = {}
for i in itertools.count(2):
cube = i**3
if cube >= limit:
break
for j in range(2, eulerlib.sqrt(limit - 1 - cube) + 1):
index = cube + j**2
ways[index] = ways.get(index, 0) + 1
result = 0
count = 0
for i in sorted(ways.keys()):
if ways[i] == TARGET_WAYS and is_palindrome(i):
result += i
count += 1
if count == TARGET_COUNT:
return result
return None
def smallest_prime_factor(n):
assert n >= 2
for i in range(2, eulerlib.sqrt(n) + 1):
if n % i == 0:
return i
return n # n itself is prime
def smallest_prime_factor(x):
for i in range(2, eulerlib.sqrt(x) + 1):
if x % i == 0:
return i
return x
def is_square(n):
return eulerlib.sqrt(n)**2 == n
def num_divisors(n):
end = eulerlib.sqrt(n)
result = sum(2 for i in range(1, end + 1) if n % i == 0)
if end**2 == n:
result -= 1
return result
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 is_prime_generating(n):
return all((n % d != 0 or isprime[d + n // d])
for d in range(2,
eulerlib.sqrt(n) + 1))
