from math import log10
from eulertools import sieve
limit = 10 ** 7
primes = set(sieve(limit))
def totients():
tots = [1] * (limit+1)
for p in primes:
tots[p] = p - 1
for i in range(2,1+limit/p):
j = p * i
while i % p == 0:
tots[j] *= p
i /= p
tots[j] *= (p-1)
return tots
def isperm(n, m):
# if not -1 < int(log10(n)) - int(log10(m)) < 1: return False
s = str(n)
t = list(str(m))
if len(s) != len(t): return False
## surprisingly, this is faster than sorted(str(n)) == sorted(str(m))
## there's an O(n) method too, which is also slower than this.
try:
for c in s:
t.remove(c)
except ValueError:
return False
return not t
from eulertools import sieve, isprime, permute
primes = list(sieve(31622))
tonum = lambda ds: reduce(lambda a,b :10*a+b, ds, 0)
def main():
for i in range(9, 2, -1):
digits = range(i,0,-1)
pandigitals = permute(tuple(digits))
for p in pandigitals:
if p[-1] % 2 == 0: continue
t = tonum(p)
if isprime(t, primes):
print t
return
if __name__ == '__main__': main()
from eulertools import sieve
from itertools import count
from operator import mul
from collections import defaultdict
primes = list(sieve(1000000))
def divisors(n):
def _numdivisors(n, acc):
if n == 1: return acc
for p in primes:
if n % p == 0:
while n % p == 0:
acc[p] += 1
n /= p
return _numdivisors(n,acc)
c = divisors.cache.get(n, None)
if c: return c
d= _numdivisors(n,defaultdict(lambda: 1))
if not d: d = 1
else: d = reduce(mul, d.values())
divisors.cache[n] = d
return d
divisors.cache = {}
def tridivisors(i):
if i % 2 == 0:
di = divisors(i/2)
diplus = divisors(i+1)
else:
di = divisors(i)
diplus = divisors((i+1)/2)
from itertools import count
import sys, math
from eulertools import sieve
from sets import Set
SIZE=99001 # a guess
def evens():
i = 2
while 1:
yield i
i += 2
primes = list(sieve(SIZE))
def checkprime(n):
sn = int(math.sqrt(n))
if sn > SIZE:
print "too small!"
sys.exit(0)
for p in primes:
if n == p: return 1
if n % p == 0:
return 0
return 1
tot = 1
pcount = 0
i = 1
evens = evens().next
while 1:
e = evens()
tot += 4
i += e
pcount+=checkprime(i)
i += e
from sets import Set
from eulertools import sieve, cachesumdiv
divisors = list(sieve(10000))
primes = Set(sieve(10000))
sumdivisors = lambda n: cachesumdiv(n, divisors)-n
amicable = []
skips = Set()
for n in range(1,10000):
if n in skips or n in primes: continue
sn = sumdivisors(n)
if sn <= 10000 and sn != n and sumdivisors(sn) == n:
amicable.append(n+sn)
skips.add(sn)
print sum(amicable)
from eulertools import sieve, isprime
from sets import Set
primes = Set(sieve(1000000))
def rotate(n):
toint = lambda ds: reduce(lambda a,b: 10*a+b, ds, 0)
digits = [int(c) for c in str(n)]
rotations = len(digits) - 1
for i in range(rotations):
digits = digits[1:] + [digits[0]]
yield toint(digits)
seen = Set()
for p in primes:
if p in seen: continue
rotations = list(rotate(p))
for r in rotations:
if r not in primes:
break
else:
seen.add(p)
seen.update(rotations)
print len(seen)
from eulertools import sieve, cachesumdiv, fast_conjoin as conjoin
from sets import Set
from itertools import count
primes = list(sieve(29000))
sumdivs = lambda n: cachesumdiv(n, primes)
def abundants():
for i in count(1):
if i > 28123: break
sd = sumdivs(i) - i
if sd > i:
yield i
abundants = list(abundants())
possibilities = [False]*28124
for i in abundants:
for j in abundants:
if i + j > 28123: break
possibilities[i+j] = True
sum = 0
for i in range(len(possibilities)):
if not possibilities[i]: sum += i
print sum
from eulertools import sieve
from sets import ImmutableSet as Set
from collections import defaultdict
d = defaultdict(lambda: [])
digits = lambda n: [int(c) for c in str(n)]
primes = [x for x in sieve(10000) if x > 1000]
digitset = [Set(digits(p)) for p in primes]
for (p,dig) in zip(primes,digitset):
## if len(dig) == 4:
d[dig].append(p)
exclude = (1487, 4817, 8147)
for (p,dig) in zip(primes, digitset):
if len(d[dig]) >= 3:
ps = sorted(d[dig])
while ps:
p, ps = ps[0], ps[1:]
for p2 in ps:
if 2*p2-p in ps:
print "%s%s%s" % (p, p2, 2*p2-p)
