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')
