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