def main(): prime_list = euler.prime_list(LIMIT) ways = collections.defaultdict(int) ways[0] = 1 for prime in prime_list: new_ways = ways.copy() for n in ways: new_ways[prime + n] += ways[n] ways = new_ways return sum(ways[prime] for prime in euler.prime_list(sum(prime_list) + 1)) % 10**16
def s_func(n): result = 0 sqrt = int((n + 1)**0.5) prime_list = euler.prime_list(n) for i in range(len(euler.prime_list(sqrt))): p = prime_list[i] ind = i + 1 q = prime_list[ind] while p * q <= n: result += m_func(p, q, n) ind += 1 q = prime_list[ind] return result
def main(): start = 200 global primes primes = prime_list(start) n = 33 while True: n += 2 if n > primes[len(primes) - 1]: primes += prime_list(n, start) start = n if not is_prime(n) and not goldbach(n): break print(n)
def main(): prime_list = euler.prime_list(LIMIT + 1000) rads = [1 for _ in range(LIMIT)] for prime in prime_list: for i in range(prime, LIMIT, prime): rads[i] *= prime squares = [i * i for i in range(2, int(LIMIT ** 0.5) + 1)] square_divisibles = sorted( {sq * i for sq in squares for i in range(1, LIMIT // sq + 1)} ) count = 0 for i_c, c in enumerate(square_divisibles): if c >= LIMIT: break if c % 1000 == 0: print(c) c_2 = c // 2 d = c / rads[c] for i_b in range(i_c - 1, -1, -1): b = square_divisibles[i_b] if b <= c_2: break if rads[c - b] * rads[b] < d: if euler.gcd1(b, c): count += c return count
def prepare_lst(): prime_list = euler.prime_list(1000) prime_list.remove(2) lst = {2} prod = 2 for prime in prime_list: rest = set() for i in range(prime): q = i * i for j in ADDITIONS: if not (q + j) % prime: break else: rest.add(i) new_lst = set() for a in lst: for i in range(prime): q = a + prod * i if q < LIMIT: if q % prime in rest: new_lst.add(q) else: break lst = new_lst prod *= prime return lst
def main(): powers_of_2 = [1] while powers_of_2[-1] < LIMIT // 2: powers_of_2.append(powers_of_2[-1] * 2) powers_of_3 = [1] while powers_of_3[-1] < LIMIT // 3: powers_of_3.append(powers_of_3[-1] * 3) matrix = [ [n for n in (p2 * p3 for p3 in powers_of_3) if n < LIMIT] for p2 in powers_of_2 ] prime_list = euler.prime_list(LIMIT) items = list(enumerate(matrix[0])) items.append((math.inf, 0)) for i in range(1, len(matrix)): new_items = [] for index, n in items: for j in range(min(index, len(matrix[i]))): new_n = n + matrix[i][j] if new_n > LIMIT: break new_items.append((j, new_n)) items += new_items d = collections.defaultdict(int) for _, n in items: d[n] += 1 total = 0 for prime in prime_list: if d[prime] == 1: total += prime return total
def main(): prime_list = euler.prime_list(LIMIT) prime_list.remove(2) prime_list.remove(5) str_prime_list = [str(n) for n in prime_list] sets = {} minimum = LIMIT * COUNT for prime in str_prime_list: int_prime = int(prime) if int_prime >= minimum: break for lowest, rest in list(sets.items()): int_lowest = int(lowest) if int_lowest + int_prime >= minimum: sets.pop(lowest) elif not check(prime, lowest): continue for lst in rest.copy(): if (sum(int(n) for n in lst) + int_lowest + int_prime) >= minimum: rest.remove(lst) elif all(check(prime, n) for n in lst): rest.append(lst.copy()) lst.append(prime) if len(lst) == COUNT1: minimum = min(minimum, sum(int(n) for n in lst) + int_lowest) rest.remove(lst) rest.append([prime]) if int_prime < minimum // COUNT: sets[prime] = [] return minimum
def main(): prime_list = euler.prime_list(LIMIT_N) diff = LIMIT_N - LIMIT_K result = 0 for prime in prime_list: temp = prime while temp <= LIMIT_N: result += prime * (LIMIT_N // temp - LIMIT_K // temp - diff // temp) temp *= prime return result
def main(): prime_set = set(euler.prime_list(100)) product_set = prime_set.copy() all_set = prime_set | {1} while product_set: product_set = { i * j for i in product_set for j in prime_set if i * j <= LIMIT } all_set.update(product_set) return len(all_set)
def main(): prime_list = euler.prime_list(1000000) prime_list.remove(2) prime_list.remove(5) total = 0 count = 0 for prime in prime_list: if LIMIT % find(prime) == 0: count += 1 total += prime if count == 40: return total return 0
def main(): prime_list = euler.prime_list(100) total = 0 for combination in itertools.combinations(prime_list, 4): maximum = combination[-1] lst = [ prime for prime in prime_list if prime < maximum and prime not in combination ] product = euler.product(combination) total += euler.is_not_divisible(LIMIT // product, lst, len(lst)) return total
def main(): prime_list = euler.prime_list(10**6) masks = collections.defaultdict(int) for prime in prime_list: for mask in all_masks(prime): masks[mask] += 1 if masks[mask] == 8: start = 1 if mask.startswith('*') else 0 for i in range(start, 10): n = int(mask.replace('*', str(i))) if euler.miller_rabin(n): return n return 0
def main(): prime_list = euler.prime_list(100000) biggest = COUNT divisors_count = [ euler.count_prime_divisors(i, prime_list) for i in range(1, biggest + 1) ] while True: if all(count == COUNT for count in divisors_count): return biggest - COUNT + 1 biggest += 1 divisors_count = divisors_count[1:] + [ euler.count_prime_divisors(biggest, prime_list) ]
def main(): prime_list = euler.prime_list(LIMIT + 1000) total = 0 ten = 1 for i in range(2, len(prime_list)): pr1 = prime_list[i] if pr1 > LIMIT: break if ten < pr1: ten *= 10 pr2 = prime_list[i + 1] n = chinese_remainder((ten, pr2), (pr1, 0)) total += n return total
def main(): prime_list = euler.prime_list(LIMIT) prime_list.remove(2) prime_list.remove(5) result = 0 for prime in prime_list: f = find(prime) while f % 2 == 0: f >>= 1 while f % 5 == 0: f //= 5 if f == 1: result += prime return sum(prime_list) - result + 2 + 5
def main(): prime_list = euler.prime_list(LIMIT) r_sums = [] temp = 0 for r in reversed(prime_list): temp += r r_sums.append(temp) r_sums.reverse() r_sums_1 = [s - len(prime_list) + i for i, s in enumerate(r_sums)] total = 0 for i, p in enumerate(prime_list): for j in range(i + 1, len(prime_list) - 1): q = prime_list[j] f_p_q = (p - 1) * (q - 1) - 1 p_q = p * q total += p_q * r_sums_1[j + 1] + f_p_q * r_sums[j + 1] return total
def main(): pascal = [[0 for _ in range(LIMIT)] for _ in range(51)] for i in range(51): pascal[i][0] = 1 for i in range(1, LIMIT): for j in range(i + 1): pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j] pascal_set = {n for row in pascal for n in row} prime_squares = [ i**2 for i in euler.prime_list(int(max(pascal_set)**0.5) + 1) ] total = 0 for n in pascal_set: for square in prime_squares: if n % square == 0: break else: total += n return total
def main(): maximum_l = 0 maximum_a = 0 maximum_b = 0 lst = euler.prime_list(1000) for b in lst: for a in range(-b + 2, 1001, 2): n = 0 length = 0 c = b while c > 1 and euler.is_prime(c, lst): # miller-rabin is slow because they all are primes n += 1 length += 1 c = n ** 2 + a * n + b if length > maximum_l: maximum_l = length maximum_a = a maximum_b = b return maximum_a * maximum_b
def main(): total = 0 lst = list(range(LIMIT1)) lst[1] = 0 nums = [2 * n * n - 1 for n in range(1000)] for prime in euler.prime_list(1000): for rest in range(1, prime): num = nums[rest] if not num % prime: if num == prime: total += 1 for i in range(rest, LIMIT1, prime): lst[i] = 0 for n in lst: if n: num = 2 * n * n - 1 if euler.miller_rabin(num): total += 1 for i in range(n, LIMIT1, num): lst[i] = 0 return total
def main(): prime_list = [] ten = 10 while len(prime_list) < LIMIT: ten *= 10 prime_list = euler.prime_list(ten) prime_list = prime_list[:LIMIT] lst = [1 for _ in prime_list] begin = 0 end = len(prime_list) - 1 while lst[begin]: power = lst[begin] + 1 if prime_list[begin] ** power < prime_list[end]: lst[end] = 0 lst[begin] += power end -= 1 else: begin += 1 n = 1 for prime, power in zip(prime_list, lst): n = (n * prime ** power) % 500500507 return n
def main(): total = 0 prime_list = euler.prime_list(int(LIMIT**0.5) + 100) for i, prime in enumerate(prime_list): upper_limit = (prime_list[i + 1] if i != len(prime_list) - 1 else prime)**2 lower_limit = (prime_list[i - 1] if i != 0 else prime)**2 for n in itertools.count(prime + 1): product = prime * n if product >= upper_limit or product >= LIMIT: break if n == prime_list[i + 1]: continue total += product for n in range(prime - 1, -1, -1): product = prime * n if product <= lower_limit: break if n == prime_list[i - 1] or product > LIMIT: continue total += product return total
def main(): str_lst = [ str(prime) for prime in euler.prime_list(10 ** 8) if euler.is_pandigital_without_zero(prime) ] total = 0 str_array = [''] index_array = [-1] lst_length = len(str_lst) while str_array: string1 = str_array.pop() ind = index_array.pop() for i in range(ind + 1, lst_length): new = string1 + str_lst[i] length = len(new) if length > 9: break if euler.is_pandigital_without_zero(new): if length == 9: total += 1 else: str_array.append(new) index_array.append(i) return total
from euler import is_prime, rotations, prime_list circular_primes = [] primes = prime_list(1000000) for p in primes: print(p) rots = rotations(str(p)) circular = True for r in rots: if not is_prime(int(r)): circular = False if circular: circular_primes.append(p) print(len(circular_primes)) print(circular_primes)
def main(): squares = [p * p for p in euler.prime_list(2 ** (POWER // 2))] return euler.is_not_divisible(2 ** POWER, squares, len(squares))
def main(): return euler.prime_list(LIMIT * 100)[LIMIT - 1]
def main(): for prime in reversed(euler.prime_list(10**7)): if euler.is_pandigital_1n(prime): return prime return 0
def main(): lst = [[1, n] for n in range(LIMIT + 1)] for prime in euler.prime_list(LIMIT + 1): for i in range(prime, LIMIT + 1, prime): lst[i][0] *= prime return lst.index(sorted(lst)[INDEX])
from fractions import Fraction import collections import euler ANSWER = 301 LIMIT = 80 PRIME_LST = euler.prime_list(LIMIT + 1) FRACTIONS = [Fraction(1, n * n) if n else 0 for n in range(LIMIT + 1)] def prepare_dict_23(): set23 = [0] for n in range(3, LIMIT + 1): if euler.prime_divisors(n, PRIME_LST) <= {2, 3}: new_set23 = set23.copy() for f in set23: new_set23.append(f + FRACTIONS[n]) set23 = new_set23 dict_23 = collections.defaultdict(int) for f in set23: dict_23[f] += 1 return dict_23 def prepare_fraction_sets(): sets = {5: [[]], 7: [[]], 13: [[]]} for prime in [5, 7, 13]: sums = [FRACTIONS[i] for i in range(LIMIT // prime + 1)] indices_lst = [[i] for i in range(LIMIT // prime + 1)]
import math import euler ANSWER = 180180 PRIME_LIST = euler.prime_list(100) LIMIT = 10**3 def decisions(lst): result = 1 for a in lst: if a == 0: break result *= (a << 1) | 1 return (result >> 1) + 1 def number(lst): result = 1 for i, power in enumerate(lst): if power == 0: break result *= PRIME_LIST[i]**power return result def new_arrays(lst): yield (lst[0] + 1, ) + lst[1:] for i in range(1, len(lst)): if lst[i - 1] == 0:
from euler import is_prime, prime_list primes = prime_list(200000) print('Primes calculated.') max = 0 num_terms = 0 for j in range(len(primes)): for i in range(len(primes)): if i + j == len(primes): break total = sum(primes[i:i+j]) if total >= 1000000: break if total % 2 == 1 and is_prime(total): num_terms = j max = total max_range = primes[i:i+j] print(num_terms, 'terms') print(max, 'total')