def is_truncatable_prime(num):
s = str(num)
l = len(s)
if not is_prime(num):
return False
for x in range(1, l):
lft = s[:x]
rgt = s[x:]
if not is_prime(int(lft)) or not is_prime(int(rgt)):
return False
return True
def find_prime_factors(num):
try:
return prime_factors[num]
except KeyError:
ret = []
if is_prime(num):
ret = [num]
else:
for n in xrange(2, num/2 + 1):
if is_prime(n) and (num % n) == 0:
ret.append(n)
prime_factors[num] = ret
return ret
def is_unusual(num):
if is_prime(num):
l = [x for x in str(num)]
lst = []
for p in permutations(l):
x = int(''.join(p))
if is_prime(x) and len(str(x)) == 4:
lst.append(x)
lst = unique(lst)
lst.sort()
if len(lst) >= 3 and contains_arithmetic_sequence(lst, 3):
#print str(lst) + " is unusual"
return True
return False
def num_consecutive_primes(f):
n = 0
while True:
r = f(n)
if r < 0 or not is_prime(f(n)):
break
n += 1
return n
def find_nth_prime(n):
s = 0
p = 2
while True:
if is_prime(p):
s += 1
if s == n:
break
p += 1
return p
def test0003(self):
from id_0003 import is_prime, prime_factors
primes = [2, 3, 5, 7, 11, 13, 17]
for x in primes:
self.assertEqual(is_prime(x), 1)
non_primes = [4, 6, 8, 10, 12, 14, 15, 16, 18]
for x in non_primes:
self.assertEqual(is_prime(x), 0)
self.assertEqual(prime_factors(2), [2])
self.assertEqual(prime_factors(3), [])
self.assertEqual(prime_factors(4), [2])
self.assertEqual(prime_factors(5), [])
self.assertEqual(prime_factors(6), [2, 3])
self.assertEqual(prime_factors(10), [2, 5])
self.assertEqual(prime_factors(13195), [5, 7, 13, 29])
def is_goldbachian(num):
for n in range(1, num/2):
try:
ts = twice_square[n]
except KeyError:
twice_square[n] = 2*n**2
ts = twice_square[n]
d = num - ts
if d > 1 and is_prime(d):
return True
return False
def count_distinct_factors(num):
try:
return distinct_factors[num]
except KeyError:
c = 0
if is_prime(num):
c = 1
else:
p = 2
while num != 1:
if num % p == 0:
c += 1
while num % p == 0:
num /= p
p += 1
distinct_factors[num] = c
return c
def totient2(n):
try:
return d_totient[n]
except KeyError:
ret = n
if is_prime(n):
ret = n - 1
else:
fact = prime_factors(n)
for p in fact:
ret = ret*(p - 1)/p
k = 1
while True:
d_totient[n**k] = (n**(k - 1))*ret
k += 1
if n**k >= 10**6:
break
return d_totient[n]
#!/usr/bin/python2
# #####################################################################
# id_0070.py
#
# Przemyslaw Kaminski <*****@*****.**>
# Time-stamp: <>
######################################################################
from id_0003 import is_prime
from id_0008 import mul
from id_0062 import is_permutation
from id_0069 import totient2
if __name__ == '__main__':
# read the wiki: http://en.wikipedia.org/wiki/Euler%27s_totient_function
lst_primes = [x for x in range(2, 4000) if is_prime(x)]
#lst_primes.reverse()
ratio = 50.0
print lst_primes
i = 1
for p in range(len(lst_primes)):
for q in range(p + 1, len(lst_primes)):
s = lst_primes[p]*lst_primes[q]
t = (lst_primes[p] - 1)*(lst_primes[q] - 1)
ss = "s = %d, t = %d" % (s, t)
if s < 10**7 and is_permutation(t, s):
ss += " -- a permutation"
r = float(s)/float(t)
if ratio > r:
ss += " -- new minimum found"
ratio = r
print ss
join_nums = lambda x, y: int(''.join([str(x), str(y)]))
for idx, x in enumerate(lst_primes):
if x > 10000:
break
maxidx = idx
for a in xrange(5, maxidx):
pa = lst_primes[a]
for b in xrange(a, maxidx):
pb = lst_primes[b]
# check this pair first
pab = join_nums(pa, pb)
pba = join_nums(pb, pa)
#if pab in lst_primes and pba in lst_primes:
if is_prime(pab) and is_prime(pba):
print "%d, %d ok so far..." % (pa, pb)
for c in xrange(b, maxidx):
pc = lst_primes[c]
pac = join_nums(pa, pc)
pca = join_nums(pc, pa)
pbc = join_nums(pb, pc)
pcb = join_nums(pc, pb)
#print "Testing %d with pac = %d, pca = %d, pbc = %d, pcb = %d" % (pc, pac, pca, pbc, pcb)
#if pac in lst_primes and pca in lst_primes and pbc in lst_primes and pcb in lst_primes:
if is_prime(pac) and is_prime(pca) and is_prime(pbc) and is_prime(pcb):
print "%d, %d, %d ok so far..." % (pa, pb, pc)
for d in xrange(c, maxidx):
nice_four = True
pd = lst_primes[d]
pad = join_nums(pa, pd)
def is_circular_prime(num):
for x in circulars(num):
if not is_prime(x):
return False
return True
#!/usr/bin/python2
# #####################################################################
# id_0050.py
#
# Przemyslaw Kaminski <*****@*****.**>
# Time-stamp: <>
######################################################################
from id_0003 import is_prime
lst_primes = []
for n in xrange(2, 10**3):
if is_prime(n):
lst_primes.append(n)
def sum_consecutive_primes(num):
i = 0
while True:
k = 0
sum_of_primes = False
tst = num
while True:
tst -= lst_primes[i + k]
if tst == 0:
return (k + 1)
if tst < 0:
break
k += 1
if lst_primes[i] > num:
break
i += 1
return 0
# generator of spiral vertices
def spiral_vertices():
cnt = 1
side = 1
while True:
jmp = 2*side
for x in range(4):
cnt += jmp
yield cnt
side += 1
if __name__ == '__main__':
ratio = 1.
primes = 0
n = 1
side = 1
f = spiral_vertices()
while ratio > 0.1:
for x in range(4):
ret = f.next()
if is_prime(ret):
primes += 1
n += 4
side += 2
ratio = float(primes)/n
print "Ratio is " + str(ratio) + ", primes = " + str(primes) + ", n = " + str(n)
if n < 10:
ratio = 1.
print side
# #####################################################################
# id_0046.py
#
# Przemyslaw Kaminski <*****@*****.**>
# Time-stamp: <>
######################################################################
from id_0003 import is_prime
twice_square = {}
def is_goldbachian(num):
for n in range(1, num/2):
try:
ts = twice_square[n]
except KeyError:
twice_square[n] = 2*n**2
ts = twice_square[n]
d = num - ts
if d > 1 and is_prime(d):
return True
return False
if __name__ == '__main__':
n = 4
while True:
num = 2*n + 1
if not is_prime(num) and not is_goldbachian(num):
print "%d is not goldbachian" % num
break
n += 1
s = str(num)
if len(s) != n:
return False
for x in s:
try:
digits.remove(x)
except ValueError:
return False
return True
def gen_pandigitals_n(n):
digits = [str(x) for x in range(1, n + 1)]
for c in permutations(digits):
yield int(''.join(c))
if __name__ == '__main__':
m = 0
N = 0
for n in range(1, 9):
f = gen_pandigitals_n(n)
while True:
try:
ret = f.next()
if ret > m and is_prime(ret):
m = ret
N = n
print '%d is largest pandigital prime so far' % m
except StopIteration:
break
print m
def sum_primes_below(n):
s = 0
for x in range(2, n):
if is_prime(x):
s += x
return s
