def truncatable(n): if not is_prime(n): return False for x in xrange(1,len(str(n))): if not is_prime(int(str(n)[:x])) or not is_prime(int(str(n)[x:])): return False return True
def num_of_divisor(n): d = dict() cur = 2 while True: if util.is_prime(cur): d[cur] = 0 while n % cur == 0: n /= cur d[cur] += 1 n = int(n) if n == 1: break elif util.is_prime(n): d[n] = 1 break if cur == 2: cur += 1 else: cur += 2 ans = 1 for (_, v) in d.items(): ans *= v + 1 return ans
def solve(): for p in primes2(3340): if p < 1000: continue p1 = p + 3330 p2 = p + 6660 if not is_prime(p1) or not is_prime(p2): continue if sorted(str(p)) == sorted(str(p1)) == sorted(str(p2)): return str(p) + str(p1) + str(p2)
def is_prime_pair(a, b): ab = int(str(a) + str(b)) if not util.is_prime(ab): return False ba = int(str(b) + str(a)) if not util.is_prime(ba): return False return True
def is_removeable_prime(n): if not is_prime(n): return False sn = str(n) for i in range(1, len(sn)): if not is_prime(int(sn[i:])): return False if not is_prime(int(sn[:i])): return False return True
def is_truncatable_prime(n): if str(n)[0] not in ['2', '3', '5', '7' ] or str(n)[-1] not in ['2', '3', '5', '7']: return False if not is_prime(n): return False n = str(n) truncs = [int(n[i:]) for i in range(len(n)) ] + [int(n[:i + 1]) for i in range(len(n))] return all([is_prime(k) for k in truncs])
def findPairs(i, primes): ''' @param i Index of primes ''' pairs = set() # startTime = time.time() for j in range(i, len(primes)): if is_prime(concatenate(primes[i], primes[j])) and is_prime(concatenate(primes[j], primes[i])): pairs.add(primes[j]) # print('calculate pair[{0}] takes {1} seconds'.format(primes[i], time.time()-startTime)) return pairs
def solve(): p = 33 while 1: p += 2 if not is_prime(p): for i in range(1, p / 2 + 1): if is_prime(p - 2 * i * i): break else: return p
def is_circular_prime(n): if not is_prime(n): return False digits = list(str(n)) checklist = ['0', '4', '6', '8'] if any([d in checklist for d in digits]): return False cycles = generate_rotation(n) while True: try: if not is_prime(int(next(cycles))): return False except StopIteration: return True
def are_all_rotations_prime(n): if n < 2: return False if not util.is_prime(n): return False s = str(n) for i in range(len(s)): s2 = s[i:] + s[:i] if not util.is_prime(int(s2)): return False print '!!', n return True
def get_prime_factors(n): result = set() for i in range(2, int(math.sqrt(n)) + 1): if n % i == 0: if is_prime(i): result.add(i) upper_divisor = int(n / i) if is_prime(upper_divisor): result.add(upper_divisor) if is_prime(n): result.add(n) return list(result)
def is_truncatable_prime(n): num, ds = digits(n) # remove digits from left to right for i in xrange(1, len(ds)): tmp_ds = ds[i:] tmp_n = int(reduce(lambda x, y: ''.join([str(x), str(y)]), tmp_ds, '')) if not is_prime(tmp_n): return False # remove digits from right to left for i in xrange(1, len(ds)): tmp_ds = ds[:len(ds)-i] tmp_n = int(reduce(lambda x, y: ''.join([str(x), str(y)]), tmp_ds, '')) if not is_prime(tmp_n): return False return True
def count_prime(a, b): n = 0 while 1: if is_prime(abs(n * n + a * n + b)): n += 1 else: return n
def main(): ans = 0 for i in permutations("123456"): temp = int(num+"".join(i)) if is_prime(temp) and temp > ans : ans = temp print ans
def solution(): count = 1 n = 3 while count < 10001: if is_prime(n): count += 1 n += 2 return n - 2
def find_primes_ceiling(self, starting_prime, ceiling) -> list: out_list = [] for current_candidate in range(starting_prime, ceiling, 2): if util.is_prime(current_candidate): out_list.append(current_candidate) print("search ceiling exceeded, primes found this run {0:,.0f}".format( len(out_list))) return out_list
def consecutive_primes(a, b): """ Find the number of consecutive primes generated by the formula n² + an + b """ n = 0 while True: if not is_prime(n * n + a * n + b): return n n += 1
def get_deepest_prime_below(sums, below): rr = [] for y in reversed(xrange(len(sums))): for x in range(len(sums[y])): n = sums[y][x] if util.is_prime(n) and n < below: rr.append(n) if rr: break return rr
def nth_prime(n): prime = 2 count = 1 k = 3 while count < n: if is_prime(k): prime = k count += 1 k += 2 return prime
def consecutive_primes(a, b): """ Find the number of consecutive primes generated by the formula n² + an + b """ n = 0 while True: if not is_prime(n*n + a*n + b): return n n += 1
def next(x): new_xs = [] str_x = str(x) for (i,digit) in enumerate(str_x + '0'): for d in range(0,10): temp = str_x[:i] + str(d) + str_x[i:] if not (i == 0 and d == 0): if util.is_prime(int(temp)): new_xs.append(int(temp)) return new_xs
def solution(): target = 2e6 i = 3 total = 2 while True: if is_prime(i): total += i i += 2 if i > target: break return total
def p131(): # n**3 + p = (n+1)**3 # p = 3n**2 + 3n + 1 cnt = 0 for n in count(1): p = 3 * (n**2) + 3 * n + 1 if p >= 1000000: break if is_prime(p): cnt += 1 print(cnt)
def solution(): count = 1 i = 3 target = 10001 while(True): if is_prime(i): count += 1 if count == target: break i += 2 return i
def pandigital_prime(n_digits): if n_digits % 2 == 0: start = int(str(n_digits) * n_digits) + 1 else: start = int(str(n_digits) * n_digits) end = 10**(n_digits - 1) digits = set("".join(str(d) for d in xrange(1, n_digits + 1))) for i in xrange(start, end, -2): if set(str(i)) == digits: if util.is_prime(i): return i
def main(): i = 0 n = 1 while i < 10001: n += 1 if is_prime(n): i += 1 print(n)
def test_keygen(self): pk, sk = self.generate_keypair(_N_BITS) # check p and q are actually safe primes self.assertGreater(sk.p, 0) self.assertGreater(sk.q, 0) self.assertTrue(util.is_prime(sk.p)) self.assertTrue(util.is_prime(sk.q)) self.assertTrue(util.is_prime((sk.p - 1) // 2)) self.assertTrue(util.is_prime((sk.q - 1) // 2)) # check their sizes self.assertEqual(sk.p.bit_length() + sk.q.bit_length(), _N_BITS) self.assertGreaterEqual(sk.p.bit_length(), _N_BITS // 2) self.assertGreaterEqual(sk.q.bit_length(), _N_BITS // 2) # check consistency of n, nsquare and g self.assertEqual(pk.n, sk.p * sk.q) self.assertEqual(pk.nsquare, pk.n**2) self.assertGreater(pk.g, 0) self.assertLess(pk.g, pk.nsquare)
def is_truncatable_prime(string, left): n = int(string) if is_prime(n): if n < 10: return True else: next = string[0:-1] if left: next = string[1::] return is_truncatable_prime(next, left) else: return False
def is_circular(n): if n in ps: return True s = str(n) ls = [] for i in range(len(s)): if not is_prime(int(s)): return False ls.append(int(s)) s = s[1:] + s[0] ps.extend(ls) return True
def solve(): """ Generate permutations of range(1, n) and concatenate to form pandigital numbers. Start with n = 10 and count down until a prime pandigital is found. """ for i in range(7, 1, -1): for p in itertools.permutations(range(i, 0, -1)): num = int("".join(str(i) for i in p)) if (num % 2 != 0) and util.is_prime(num): print num return
def main(): prime_perc = 100 total = 1 num_prime = 0 i = 1 while prime_perc >= .10: i+=2 total += 4 for d in diagonal(i): num_prime += is_prime(d) prime_perc = float(num_prime)/total print i,prime_perc
def get_xth_prime(xth): primes_found = 0 x = 2 while True: if is_prime(x): primes_found += 1 if primes_found == xth: return x x += 1
def prime_proof(str_n): l = len(str_n) for i in range(l): ln = list(map(int, str_n)) ln[i] = 0 c = int(reduce(lambda x, y: str(x) + str(y), ln)) # print(c, l - i - 1) for j in range(10): r = c + j * 10**(l - i - 1) if is_prime(r): return False # print('\t', r) return True
def circular_primes(max_n): res = [] for i in itertools.chain((2,), xrange(3, max_n + 1, 2)): s = str(i) l = len(s) if l > 1 and any([EVENS.search(s), "5" in s]): continue permutations = [int("".join(p)) for p in itertools.permutations(s, l)] for p in permutations: if not util.is_prime(p): break else: res.extend(permutations) return res
def ppd(): "pandigital primes descending" from itertools import permutations from math import floor from util import is_prime for n in range(0, 9): digits = '987654321'[n:] if sum(map(int, digits)) % 3 == 0: # every permutation will be divisible by 3 continue for p in permutations(digits): x = int(''.join(p)) if is_prime(x): yield x
def __init__(self, n: IntType) -> None: super().__init__() self.n = int(n) assert n >= 1 self._props[RingProperties.FINITE] = True self._props[RingProperties.FIELD] = is_prime(n) self._props[RingProperties.ORDERED] = False # Register coercions. Only one we've got is from ZZ. def ZZ_coercion(x: IntegerElt) -> ZModElt: return self(x.value) self._register_coercion(ZZ, ZZ_coercion)
def p179(): # 60 min > run time (bad..) L = 10**7 cnt = 1 # 2, 3 last_fc = 0 for i in range(2, L): if is_prime(i): last_fc = 0 continue fc = factor_cnt(i) if last_fc == fc: cnt += 1 print([i], fc, last_fc) last_fc = fc print('[179]: ', cnt) return
def main(ceiling): """Tests to see if next number in sequence 6i+-1 is prime""" primes = [2, 3] i = 1 switch = True while primes[-1] <= ceiling: if switch: n = 6*i - 1 switch = False else: n = 6*i + 1 switch = True i+=1 if is_prime(n, primes): primes.append(n) #print primes[-1] return primes
def find_primes_timelimit(self, starting_prime, timelimit_seconds) -> list: start_time = dt.datetime.now() print( f"find primes timelimit start time: {start_time.strftime('%H:%m')}" ) current_candidate = starting_prime + 2 out_list = [] while (dt.datetime.now() - start_time).seconds < timelimit_seconds: if util.is_prime(current_candidate): out_list.append(current_candidate) current_candidate += 2 print("search time limit exceeded, primes found this run {0:,.0f}". format(len(out_list))) return out_list
def number_of_sum(m, n, d): if n == 0: return 1 elif m == 1: return 0 elif m == 2 and (n % 2) != 0: return 0 if (m, n) in d: return d[(m, n)] ans = 0 ans += number_of_sum(2, n - 2, d) for i in range(3, min(m + 1, n + 1), 2): if util.is_prime(i): ans += number_of_sum(i, n - i, d) d[(m, n)] = ans return ans
def solution(): ratio = 1.0 start = 1 step = 2 count = 1 countPrime = 0 side = 1 while ratio > 0.1: diagonals = [start + i * step for i in xrange(1, 5)] # print(diagonals) for n in diagonals: if is_prime(n): countPrime += 1 count += 4 ratio = float(countPrime) / float(count) # print(countPrime, count, ratio) # print(start, step, side) start = diagonals[3] step += 2 side += 1 return (side - 1) * 2 + 1
def main(): # Note that the constant term of the quadratic must be prime, because # when n = 0 it equals the constant term. # Also note that when n equals the constant term, every term will be # divisible by n and our list of primes terminates. answer = 0 max_primes = 0 primes = set(x for x in range(1000) if is_prime(x)) for b in primes: for a in range(1, 1000): for a, b in ((a, b), (a, -b), (-a, b), (-a, -b)): q = quadratic(a, b) n = 0 while q(n) in primes: n += 1 if n > max_primes: answer = a * b max_primes = n print(answer)
def run(a, b): n = 0 while is_prime(n**2 + a*n + b): n += 1 return n
#!/usr/bin/env python3 import sys sys.path.insert(0, '../../') import util if __name__ == '__main__': max_len = 0 ans = 0 for a in range(-999, 1000): for b in range(-1000, 1001): cur = 0 while True: f = cur**2 + a * cur + b if util.is_prime(f): cur += 1 else: if cur > max_len: max_len = cur ans = a * b break print(ans)
def prime_genr(n=1): while True: if ut.is_prime(n): yield n n += 1
def prime_list(lb=1, ub=100): return [n for n in range(lb, ub) if ut.is_prime(n)]
#!/usr/bin/env python3 import sys import math import itertools sys.path.insert(0, '../../') import util if __name__ == '__main__': max_ans = 0 for n in range(9, 0, -1): lex = [str(i) for i in range(1, n + 1)] for i in itertools.permutations(lex): num = int(''.join(i)) if util.is_prime(num) and num > max_ans: max_ans = num if max_ans > 0: break print(max_ans)
from util import is_prime for x in xrange(1000, 9999+1): if is_prime(x): perms = x, int(str(x)[1:]+str(x)[:1]), int(str(x)[2:]+str(x)[:2]) if x == 1487: print perms[2]-perms[1] == perms[1]-perms[0] raw_input() if perms[2]-perms[1] == perms[1]-perms[0]: print 'found it'
import util primeCounter=0 i=0 while(primeCounter<10001): i+=1 if(util.is_prime(i)): primeCounter+=1 print primeCounter print i
] return [ each_prime, ] + filtered_primes return False if __name__ == '__main__': # test cases # assert is_permutation(1487, 4817) # assert is_permutation(1487, 8147) # approaches # 1 # list primes in 1000 to 9999, find permutations # 2 # for each prime in sequence, check if any permutations also prime # approach 1 primes = [n for n in range(999, 10000) if ut.is_prime(n)] for each_prime in primes: prime_permuts = [n for n in primes if is_permutation(each_prime, n)] same_abs = find_same_abs(prime_permuts) if same_abs and same_abs[0] != 4817: print(same_abs) # 296962999629
#!/usr/bin/env python3 import sys import math sys.path.insert(0, '../../') import util if __name__ == '__main__': cur = 3 primes = {2: True} while True: if not util.is_prime(cur): have_sum = False for i in range(int(math.sqrt(cur / 2)) + 1): if (cur - 2 * i**2) in primes: have_sum = True if not have_sum: print(cur) break else: primes[cur] = True cur += 2
return int(s[-1] + s[:-1]) if __name__ == '__main__': limit = 1000000 l = set() not_l = set() for i in range(limit): if i in l or i in not_l: continue if '0' in str(i): continue if util.is_prime(i): temp = set([i]) cur = i valid = True for j in range(len(str(i)) - 1): cur = circular(cur) temp.add(cur) if not util.is_prime(cur): valid = False if valid: l |= temp else: not_l |= temp print(len(l))
#!/usr/bin/env python3 import sys sys.path.insert(0, '../../') import util if __name__ == '__main__': count = 11 l = set() cur = 11 while count > 0: if util.is_prime(cur): leng = len(str(cur)) valid = True cur_left = cur cur_right = cur for i in range(leng - 1): cur_left = int(str(cur_left)[1:]) cur_right = int(str(cur_right)[:-1]) if util.is_prime(cur_left) and util.is_prime(cur_right): pass else: valid = False break if valid:
def get_biggest_pandigital_prime(): for biggest_digit in range(1, 10)[::-1]: for n in pandigitals(biggest_digit): if util.is_prime(n): return n return None
def main(): print(sum(n for n in range(2, 2000000) if is_prime(n)))
from util import is_prime, primes pg = primes() while next(pg) <= 56003: pass answer = None for p in pg: s = str(p) for d in range(3): if str(d) in s: n = 1 for e in range(d+1, 10): if is_prime(int(s.replace(str(d), str(e)))): n += 1 if n >= 8: answer = p break if answer: break print(answer)
prime_pair_cache[key] = r return r def is_prime_set(selected, prime_pair_cache): for i in range(len(selected)): a = selected[i] for j in range(i): b = selected[j] if not is_prime_pair_caching(a, b, prime_pair_cache): return False return True print 'getting primes up to %d...' % PRIMES_UP_TO primes = [] for i in range(2, PRIMES_UP_TO): if util.is_prime(i): primes.append(i) print 'getting prime pairs... (%d primes)' % (len(primes),) prime_pair_cache = {} prime2with = collections.defaultdict(list) count = 0 for pair in itertools.combinations(primes, 2): if count % 100000 == 0: print 'checked %d pairs...' % count count += 1 if is_prime_set(pair, prime_pair_cache): a, b = pair prime2with[a].append(b) prime2with[b].append(a)
break if cur_div == 2: cur_div += 1 else: cur_div += 2 return count if __name__ == '__main__': cur = 644 count = 0 while True: if util.is_prime(cur): count = 0 else: if primes_num(cur) == 4: count += 1 else: count = 0 if count == 4: print(cur - 3) break cur += 1
import util if __name__ == "__main__": n = 10 print(n, util.is_prime(n))