def is_truncatable(num: int) -> bool: if not primes.is_prime(num): return False mult = 10 while mult < num: if not primes.is_prime(num % mult) or not primes.is_prime(num // mult): return False mult *= 10 return True
def solution(): t_primes = [] left_right = [3, 7] right_left = [2, 5, 3, 7] while len(t_primes) < 11: left_right = [ add_digit(n, d, 1) for n in left_right for d in range(1, 10) ] right_left = [ add_digit(n, d, 0) for n in right_left for d in range(1, 10) ] left_right = [p for p in left_right if is_prime(p)] right_left = [p for p in right_left if is_prime(p)] t_primes += [p for p in left_right if p in right_left] return sum(t_primes)
def problem_50(): limit = 10**6 # find the smallest list of primes which will sum up to at least the limit we set above for x in count(1): primes = list(get_primes_under(10**x)) if sum(primes) > limit: break # starting with the longest possible sequence (every element in the list), and then working # to smaller sequence lengths for length in reversed(range(1, len(primes) + 1)): # Use a "sliding window" approach. Starting at the low end of the list, grab the first # `length` elements and check it. Then slide the window right 1 element, and grab those, # and check it, etc for start in range(len(primes)-length): candidate = sum(primes[start:start+length]) # if the candidate sum is bigger than the limit, no point in checking any more windows # of size `length`. Break the inner loop, and reduce the length if candidate >= limit: break # if the candidate sum is prime, we're done! if is_prime(candidate): print(candidate) return
def nth_prime(n): """Returns nth prime""" current = 1 primes = 0 while primes < n: current += 1 if is_prime(current): primes += 1 return current
def check(num): if '200' not in str(num): return False for i in xrange(len(str(num))): for j in range(0, 10): new_num = int(str(num)[:i] + str(j) + str(num)[i + 1:]) if is_prime(new_num): return False return True
def is_circular_prime(n): """ Returns True is n is a circular prime: that is, if n itself is prime, as are all rotations of its digits. """ # if n itself is not prime, it's certainly not a circular prime if not is_prime(n): return False # convert n to a list of digits so we can rotate it n = list(str(n)) # For every rotation of the digits of n, convert that back into an int, and check primality # If any of them are not, return False rotated_number = lambda list, i: int(''.join(rotate(list, i))) if any(not is_prime(rotated_number(n, i)) for i in range(1, len(n))): return False # We made it here, so n and all rotations of n are prime return True
def solution(): # primes_list = seive_of_erat(1000000000) # primes_set = set(primes_list) n = 1 all_corners = 5 corner_primes = 3 while corner_primes / all_corners >= 0.1: n += 1 end = (2*n + 1) * (2*n + 1) all_corners += 4 corner_primes += len([1 for c in get_corners(n) if is_prime(c)]) return 2*n + 1
def solution(): digits = [1, 2, 3, 4, 5, 6, 7] best = 0 current = digits while len(digits) < 10: conc = int("".join([str(d) for d in current])) if is_prime(conc): best = conc current = next_perm(current) if not current: digits.append(digits[-1] + 1) current = digits return best
def main(): prime_count = 0 total_count = 1 num = 1 for side_length in itertools.count(3, 2): for _ in range(4): total_count += 1 num += side_length - 1 if primes.is_prime(num): prime_count += 1 if prime_count / total_count < .1: return side_length
def can_be_written_as_prime_plus_twice_square(n): """ Returns True if n can be written as the sum of a prime and twice a square number, or returns False otherwise. """ if is_prime(n): return True # For every prime under n, find what value of x satisfies: n = prime + 2x^2 # If any of those values x are an integer, then n can be written as prime + 2x square number for prime in get_primes_under(n): x = ((n - prime) / 2) ** 0.5 if x % 1 == 0: return True # If we get here, n cannot be written as prime + 2x square number return False
def count_primes_of_quadratic(a, b): """ Returns the number of consecutive primes produced by the quadratic equation n² + an + b, with n starting at 0. """ n = 0 count = 0 while True: if is_prime(n*n + a*n + b): count += 1 n += 1 else: break return count
def ana_solve(self): solution = 0 primeList = [5, 7, 11, 13, 17, 19, 23] combos = combinations(primeList, 3) primeCombos = [] for c in combos: s = sum(c) if primes.is_prime(s): primeCombos.append((c, s)) counts = Counter([pc[1] for pc in primeCombos]) bigC = [] for c in counts: if counts[c] >= 4: bigC.append(c) candidates = [] for pc in primeCombos: if pc[1] in bigC: candidates.append(pc) candidates.sort(key=lambda x: x[1]) print(candidates) print('analytical solution = ', solution)
def problem_58(): # These define the north-east and the south-west spokes, for consecutive n starting at n=0 ne_spoke = lambda n: (2*n + 1)**2 sw_spoke = lambda n: 4*(n**2) + 1 # These define the north-west and the south-east spokes, for consecutive n starting at n=1 nw_spoke = lambda n: 4*(n**2) - 6*n + 3 se_spoke = lambda n: 4*(n**2) - 10*n + 7 all_spoke_values = set() prime_spoke_values = set() for n in count(0): for value in (ne_spoke(n), sw_spoke(n), nw_spoke(n+1), se_spoke(n+1)): all_spoke_values.add(value) if is_prime(value): prime_spoke_values.add(value) if n > 1 and (len(prime_spoke_values) / len(all_spoke_values)) < 0.10: spiral_side_length = 2*n + 1 print(spiral_side_length) break
def concats_to_prime(p1, p2): """ Check if both concatenations of primes p1 and p2 (p1+p2, and p2+p1), form a prime. """ p1, p2 = str(p1), str(p2) t1, t2 = int(p1 + p2), int(p2 + p1) return all(is_prime(t) for t in (t1, t2))
# It was proposed by Christian Goldbach that every odd composite number can be written as the sum of a prime and twice a square. # 9 = 7 + 2×1**2 # 15 = 7 + 2×2**2 # 21 = 3 + 2×3**2 # 25 = 7 + 2×3**2 # 27 = 19 + 2×2**2 # 33 = 31 + 2×1**2 # It turns out that the conjecture was false. # What is the smallest odd composite that cannot be written as the sum of a prime and twice a square? from utils.primes import primesfrom2to, is_prime num = 1 while True: found = False num += 2 if is_prime(num):continue pl = primesfrom2to(num) for p in pl: for i in range(1, int(((num - p) / 2)**0.5) + 1): if num == p + 2 * i**2: found = True break if found: break if not found: print(num) break
def is_circular_prime(num: int) -> bool: for rotation in rotate(num): if not is_prime(rotation): return False return True
def test_evens_are_not_prime(self): self.assertFalse(is_prime(4)) self.assertFalse(is_prime(8))
def test_2_is_prime(self): self.assertEquals(True, is_prime(2))
# We shall say that an n-digit number is pandigital if it makes use of all the digits 1 to n exactly once. For example, 2143 is a 4-digit pandigital and is also prime. # What is the largest n-digit pandigital prime that exists? from utils.primes import is_prime from itertools import permutations ans = 0 p = ['1','2','3'] for i in range(4,10): p += [str(i)] for s in permutations(p): v = int(''.join(s)) if is_prime(v): # print(v) ans = max(ans, v) print(ans)
def test_13_is_prime(self): self.assertTrue(is_prime(13))
# There are no arithmetic sequences made up of three 1-, 2-, or 3-digit primes, exhibiting this property, but there is one other 4-digit increasing sequence. # What 12-digit number do you form by concatenating the three terms in this sequence? from itertools import permutations from utils.primes import primesfrom2to, is_prime found = False for p in primesfrom2to(10000): if p < 1000:continue perms = tuple(permutations(list(str(p)))) if ('1','4','8','7') in perms:continue for s1 in perms: n1 = int(''.join(s1)) if n1 < 1000:continue if not is_prime(n1):continue for s2 in perms: if s2 == s1:continue n2 = int(''.join(s2)) if n2 < 1000:continue if not is_prime(n2):continue for s3 in perms: if s3 == s1 or s3 == s2:continue n3 = int(''.join(s3)) if n3 < 1000:continue if not is_prime(n3):continue if abs(n1 - n2) == abs(n2 - n3): found = True if found:break if found:break if found:break
# 15 = 3 × 5 # The first three consecutive numbers to have three distinct prime factors are: # 644 = 2**2 × 7 × 23 # 645 = 3 × 5 × 43 # 646 = 2 × 17 × 19. # Find the first four consecutive integers to have four distinct prime factors. What is the first of these numbers? from utils.primes import is_prime from utils.common import prime_factors num = 2 * 3 * 5 * 7 while True: if is_prime(num+3): num += 4 continue if is_prime(num+2): num += 3 continue if is_prime(num+1): num += 2 continue n1 = len(set(prime_factors(num))) == 4 n2 = len(set(prime_factors(num+1))) == 4 n3 = len(set(prime_factors(num+2))) == 4 n4 = len(set(prime_factors(num+3))) == 4 if n1 and n2 and n3 and n4: print(num) break
def main(): for x in itertools.count(9, 2): if not primes.is_prime(x) and not is_goldbach_num(x): return x
def test_negatives_are_notprime(self): self.assertFalse(is_prime(-3)) self.assertFalse(is_prime(-7))
# , where |a|<1000 and |b|≤1000 # where |n| # is the modulus/absolute value of n # e.g. |11|=11 and |−4|=4 # Find the product of the coefficients, a # and b, for the quadratic expression that produces the maximum number of primes for consecutive values of n, starting with n=0. from utils.primes import is_prime rangea = 1000 rangeb = 1001 max_n = 0 for a in range(-rangea, rangea): for b in range(-rangeb, rangeb): n = 0 while True: num = n**2 + a * n + b if not is_prime(num): if n >= max_n: max_n = n max_a = a max_b = b # print(max_a, max_b, max_n) break n += 1 # print(max_a, max_b, max_n) print(max_a * max_b)