def solve(n):
primes = get_primes(n)
primes_set = set(primes)
size = len(primes_set)
print size
ans = 41
max_length = 5
for i in range(0, size):
total = 0
if i % 1000 == 0:
print i
for j in range(i, size):
total += primes[j]
if total in primes_set:
length = j-i+1
if max_length < length:
max_length = length
ans = total
if total > n: break
return ans
def solve(n):
primes = get_primes(n)
primes_set = set(primes)
size = len(primes_set)
print size
ans = 41
max_length = 5
for i in range(0, size):
total = 0
if i % 1000 == 0:
print i
for j in range(i, size):
total += primes[j]
if total in primes_set:
length = j - i + 1
if max_length < length:
max_length = length
ans = total
if total > n: break
return ans
def testing_primality_checkers():
prime_list = algos.get_primes()
#goes up to around 100k in primes_list
for i in xrange(1, 50000):
#print "testing %d" %i
is_prime = i in prime_list
mr_is_prime, steps = miller_rabin.miller_rabin(i, 10)
if is_prime != mr_is_prime:
print "was bad"
def testing_prime_gen():
prime_list = algos.get_primes()
for i in xrange(0, 100): # 1000 iterations of tests
print i,
p, _ = prime_generators.prime_gen1(random.randint(3, 5), 7)
print p
if p not in prime_list:
print "FAILED"
return
print "SUCESS"
def solve(n):
limit = 10000000
primes = algos.get_primes(limit)
i = 1
s = 0
while True:
s += i
if s > limit: assert 'increase limit'
divisors = algos.number_of_divisors(s, primes)
print s, divisors
if divisors >= n:
return s
i += 1
def solve(n, m):
primes = algos.get_primes(m)
proper_divisors_sum = {}
for i in range(2, m):
proper_divisors_sum[i] = algos.divisors_sum(i, primes=primes) - i
amicable_numbers = []
for i in range(2, n):
proper = proper_divisors_sum[i]
if proper != 1 and proper != i:
proper_proper = proper_divisors_sum[proper]
if proper_proper == i:
print i, proper, proper_proper
amicable_numbers.append(i)
return sum(amicable_numbers)
def solve():
primes = algos.get_primes(10000)
primes_set = set(primes)
for i in range(1000, 10000):
permutations = get_permutations(i)
p = []
for j in permutations:
if j in primes_set:
primes_set.remove(j)
p.append(j)
p = list(set(p))
if len(p) >= 3:
for i in range(len(p)):
for j in range(i + 1, len(p)):
for k in range(j + 1, len(p)):
if p[j] - p[i] == p[k] - p[j]:
print p[i], p[j], p[k]
return
def solve():
primes = algos.get_primes(10000)
primes_set = set(primes)
for i in range(1000, 10000):
permutations = get_permutations(i)
p = []
for j in permutations:
if j in primes_set:
primes_set.remove(j)
p.append(j)
p = list(set(p))
if len(p) >= 3:
for i in range(len(p)):
for j in range(i+1, len(p)):
for k in range(j+1, len(p)):
if p[j] - p[i] == p[k] - p[j]:
print p[i], p[j], p[k]
return
def solve(n):
primes = get_primes(n)
return sum(primes)
import math
import algos
import collections
LIMIT = 1000000
primes = algos.get_primes(LIMIT)
#distinct_factors = {i: len(set(algos.factorize(i))) for i in range(2, LIMIT)}
#distinct_factors = {i: len(set(algos.factorize(i))) for i in range(2, LIMIT)}
distinct_factors = {}
for prime in primes:
for j in range(prime, LIMIT, prime):
distinct_factors[j] = distinct_factors.get(j, 0) + 1
def solve(n):
cont = 0
for i in range(2, LIMIT):
if distinct_factors[i] == n:
cont += 1
if cont == n:
return i - n + 1
else:
cont = 0
raise Exception('should increase LIMIT')
if __name__ == '__main__':
def solve(n):
primes = get_primes(20 * n)
return primes[n - 1]
def test_get_primes(self):
upper_bound = 20 # Included
expected = [2, 3, 5, 7, 11, 13, 17, 19]
result = algos.get_primes(upper_bound)
self.assertEqual(expected, result)
def solve(n):
primes = get_primes(20 * n)
return primes[n-1]
