def decomposition(n: int):
""" Decomposition of number on elliptic curve """
primes = lib.get_primes(up_to=300000)
# 1024 bit field
p_field = 95777621695595220893827582455568322949360165363785871654710150652523523455505729368460822100696774504239394103463514086278256724517146426653923971783093980678357933040312165712079620906481360086474298714890888636873090643116431715358613362273906310756306548690826034551206713409853566409729418426944350021177
while True:
A, B, Q = elliptic.generate_curve(p_field)
i = 0
# 3. Enumerating all prime numbers
while i < len(primes):
p = primes[i]
i = i + 1
if p >= n:
break
# Round down
alpfa = math.floor(0.5 * math.log10(n) / math.log10(p))
j = 0
# 5. Do following actions
while j <= alpfa:
_, l_denominator = elliptic.mul_point_on_number(
Q, p, A, p_field)
d = int(sympy.gcd(n, l_denominator))
if 1 < d < n:
return d
j = j + 1
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# https://projecteuler.info/problem=10
# 142913828922
from lib import get_primes
if __name__ == '__main__':
primes = get_primes(2000000)
res = 0
for el in primes:
res += el
print(res)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# https://projecteuler.info/problem=12
# 76576500
from lib import get_primes, get_devides
if __name__ == '__main__':
n = 1
limit = 500
number = int((n + 1) * n * (1 / 2))
primes = get_primes(100000)
while True:
count = get_devides(number, primes)
if count > limit:
break
n += 1
number += n
print(number)
target = 8
lt_llim = partial(lt, llim)
def get_mask(digit):
def mask_out(t):
x, y = t
if x == '0':
return y
else:
return '0'
for x in range(1, 2**limit-1):
mask = "0" * limit + bin(x)[2:]
mask = mask[-limit:]
masked = reduce(concat, lib.zipWith(mask_out, mask, str(digit)))
yield map(int, (mask, masked))
def get_primes_streak(start):
hits = []
for mask, masked in get_mask(start):
primes = filter(lib.is_prime, filter(lt_llim, (masked + mask * x for x in range(10))))
if len(primes) >= target:
return primes[0]
return False
for x in ifilter(lt_llim, lib.get_primes(lim)):
s = get_primes_streak(x)
if s:
print s
break
import lib
import math
lim = 10000
primes = list(lib.get_primes(lim))[1:]
primes_s = set(primes)
double_squares = set(x*x*2 for x in range(int(math.sqrt(lim))))
found = False
for x in range(33, lim, 2):
if x in primes_s:
continue
for p in primes:
diff = x - p
if diff <= 1:
found = True
print x
break
if diff in double_squares:
break
if found:
break
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# https://projecteuler.info/problem=7
# 104743
from lib import get_primes
if __name__ == '__main__':
primes = get_primes(110000, 10001)
print(primes[-1])
import itertools
import lib
# n^2 + an + b
def num_euler(a, b):
for n in itertools.count():
if not lib.is_prime(n*n + a*n + b):
return n
if __name__ == '__main__':
assert num_euler(1, 41) == 40
assert num_euler(-79, 1601) == 80
max_coef = None
max_num = -1
for a, b in itertools.product(range(-999, 1000, 2), lib.get_primes(1000)):
n = num_euler(a,b)
if n > max_num:
max_num = n
max_coef = (a,b)
print max_coef
from lib import gcd, get_primes
import sys
primes = list(get_primes(500))
def small_factor(d):
# the answer cannot have a large prime in it, since that makes it
# more resilient - so we can be fast and lazy
f = []
for x in primes:
while d % x == 0:
f.append(x)
d /= x
if not d == 1:
# we found high factors
return False
else:
return f
def cmp_frac((n1, d1), (n2, d2)):
return cmp(n1 * d2, n2 * d1)
def reduce_frac((n, d)):
g = gcd(n, d)
return n / g, d / g
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# https://projecteuler.info/problem=3
# 6857
from lib import get_primes
from math import sqrt, ceil
if __name__ == '__main__':
number = 600851475143
primes = get_primes(ceil(sqrt(number)))
for el in range(len(primes) - 1, 0, -1):
if number % primes[el] == 0:
print(primes[el])
exit(0)
exit(1)
import lib
def cycle(x):
x = str(x)
for each in range(0, len(x)):
yield int(x[each:]+ x[:each])
assert list(cycle(1235)) == [1235, 2351, 3512, 5123]
primes = set(lib.get_primes(1000000))
candidates = set(primes)
cyclical = set()
while candidates:
c = list(cycle(candidates.pop()))
for prime in c:
if not prime in primes:
break
else:
for x in c:
cyclical.add(x)
candidates.discard(x)
print len(cyclical)
import lib
def repend_length(d):
for x in range(1, d+1):
if 10**x % d == 1:
return x
assert False
repend_lengths = ((repend_length(x), x) for x in lib.get_primes(1000) if x > 10)
print max(repend_lengths)[1]
