def first_P_div_by(n):
cached_prime(10**6)
i = 1
while True:
i += 1
if P(i) % n == 0:
return (i, P(i))
def first_n_partitions(n):
cached_prime(10**6)
i = 0
while True:
i += 1
if b_n(i) >= n:
return i
if i % 1000 == 0: print i
def find_family():
for p in primes:
for m in masks(p):
family = [m.replace('X', str(i)) for i in range(10)]
prime_family = filter(lambda x: cached_prime(int(x)), family)
if len(prime_family) == family_size:
print prime_family
print m
print p
from helpers import factor, cached_prime, d_factor
from fractions import gcd
from pprint import pprint
from math import pi, cos
def totient(n):
f = list(factor(n))
prod = 1
for p in f:
prod *= (1 - float(1) / p)
return int(round(prod * n))
def totient1(n):
return sum([ gcd(k, n) * cos( 2 * pi * float(k) / n ) for k in range(1, n +1)])
s = 0
limit = 10**6+1
cached_prime(limit)
for i in range (2, limit):
s += totient(i)
if i % 100 == 0: print i
print s
return count
def get_diag_count(n):
return 2 * (n - 1) + 1
def corners(m=None):
i = 1
while m is None or i < m:
size = 2 * i + 1
c1 = size ** 2
c2 = c1 - (size - 1)
c3 = c1 - 2 * (size - 1)
c4 = c1 - 3 * (size - 1)
yield (size, c2, c3, c4)
i += 1
size = 1000000
cached_prime(size)
total = 1
primes = 0
for c in corners():
total += 4
primes += len(filter(is_prime, c[1:]))
if ((primes * 1000 / total) / 10.0) < 10:
print c[0]
break
from helpers import factor, cached_prime, prime_gen
from math import sqrt
def totient(n):
f = factor(n)
prod = 1
for p in f:
prod *= (1 - float(1) / p)
return int(round(prod * n))
limit = 1000000
cached_prime(1000000)
prod = 1
for p in prime_gen():
prod *= p
if prod <= limit:
t = totient(prod)
print (prod, t, float(prod) / t)
else:
break
from helpers import cached_prime, all_factors limit = 10**8 cached_prime(limit + 1) for i in range(2, limit + 1): list(all_factors(i))
from helpers import cached_prime, global_primes
limit = 1000000
cached_prime(limit)
primes = global_primes()
max_length = 0
data = None
for i in range(len(primes)):
length = 1
while True:
if i+length > len(primes): break
s = sum(primes[i:i+length])
if s > limit:
break
if cached_prime(s):
if max_length < length:
print "Found length %s %s (%s%%)" % (length, s, 100 * i / len(primes))
max_length = length
length += 1
def is_goldbach(n):
for sq in lower_twice_squares(n):
if cached_prime(n - sq):
return True
return False
from math import sqrt
from helpers import cached_prime
def lower_twice_squares(n):
i = 1
while i**2 * 2 < n:
yield i**2 * 2
i += 1
def is_goldbach(n):
for sq in lower_twice_squares(n):
if cached_prime(n - sq):
return True
return False
cached_prime(100000)
i = 3
while True:
if not cached_prime(i) and not is_goldbach(i):
print i
break
i += 2
from helpers import all_factors, cached_prime, factor
from collections import defaultdict
limit = 10000
visited = defaultdict(bool)
cached_prime(limit * 10)
numbers = []
for i in range(1, limit):
if not visited[i]:
s = sum(all_factors(i)) - i
if i == sum(all_factors(s)) - s:
if i != s:
numbers.append(i)
numbers.append(s)
print (i, s)
visited[i] = True
visited[s] = True
print sum(numbers)
