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 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 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 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 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 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(): 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
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))