# The incredible formula n² − 79n + 1601 was discovered, which produces 80 # primes for the consecutive values n = 0 to 79. The product of the # coefficients, −79 and 1601, is −126479. # Considering quadratics of the form: # n² + an + b, where |a| < 1000 and |b| < 1000 # 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. import time import primes crible = primes.Sieve(100000) l = crible.listPrimes() first_primes = l[:2000] # we extract the 200 first primes def f(a, b): """ int*int -> int->int """ g = lambda n: (n**2 + a * n + b) return g def find(a, l): """ int * int list -> bool : find if a is in l assuming l sorted """ i = 0 while (l[i] != a) and (l[i] < a): i += 1
# # # Project Euler : probleme 41 # # # # # # ========================================================================== # # 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? import time import primes as pm s = pm.Sieve(10**7) lst_primes = s.listPrimes() # list of primes under 10**9 def check_pandigital(n): """ int -> bool : check if n is a pandigital number""" length = len(str(n)) return set(range(1, length + 1)) == set(map(int, list(str(n)))) def euler_41(): """ unit -> int : find the largest n-pandigital prime """ # we start from the end of the list (the largest primes) # so the first we find if the largest. for i in reversed(lst_primes): if check_pandigital(i):
# 9 = 7 + 2×12 # 15 = 7 + 2×22 # 21 = 3 + 2×32 # 25 = 7 + 2×32 # 27 = 19 + 2×22 # 33 = 31 + 2×12 # 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? import primes as pr import time crible = pr.Sieve(10**4) prime_lst = crible.listPrimes() # list of primes def is_sqrt(n): """ int -> bool : is n a squared number """ x = n y = (x + 1) / 2 while y < x: x = y y = (x + n / x) / 2 return x * x == n def is_solution(n): """ int -> bool : try to find if n can be written as prime + 2*square """
# ========================================================================== # # The number 3797 has an interesting property. Being prime itself, it is possible # to continuously remove digits from left to right, and remain prime at each # stage: 3797, 797, 97, and 7. Similarly we can work from right to # left: 3797, 379, 37, and 3. # Find the sum of the only eleven primes that are both truncatable from left to # right and right to left. # NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes. import time import primes crible = primes.Sieve(10**6) crible_list = crible.listPrimes() def is_truncatable_prime(n): """ int -> bool : test if n is a truncatable prime """ lth = len(str(n)) # We check quikly if if not (int(str(n)[0]) in [2, 3, 5, 7]): return False trunc_lst = [] # a list containing the truncation of n for i in xrange(1, lth): trunc_lst.append(int(str(n)[0:i])) trunc_lst.append(int(str(n)[i:lth])) g = lambda n: n in crible_list return all(map(g, trunc_lst))
# The arithmetic sequence, 1487, 4817, 8147, in which each of the terms increases # by 3330, is unusual in two ways: (i) each of the three terms are prime, and, (ii) # each of the 4-digit numbers are permutations of one another. # # 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? import time import primes # we generate the 4 digits prime numbers pr_lst = primes.Sieve(10**4).listPrimes() # we notice there is two parameters : # * the gap of the arithemtic sequence # the gap is roughtly between [1 - 4500] since all primes are 4-digits # 1000 + 2*gap < 10**5 # * the first prime number # which starts from 1009 up to 9973 def explode(n): """ int -> int list """ if n < 10: return [n]
# # # # # ========================================================================== # # The number, 197, is called a circular prime because all rotations of the # digits: 197, 971, and 719, are themselves prime. # There are thirteen such primes below 100: 2, 3, 5, 7, 11, 13, 17, 31, 37, 71, # 73, 79, and 97. # How many circular primes are there below one million? import time import primes as p crible = p.Sieve(1000000) # a sieve for getting primes below 10**6 first_primes = crible.listPrimes() def rotate(n): """ int -> int list : return a list containg circular rotation of n""" rotlist = [] m = str(n) counter = 0 while counter < len(str(n)): m = m[1:] + m[0] # rotation one time : one step left rotlist.append(int(m)) counter += 1 return rotlist
# 41 = 2 + 3 + 5 + 7 + 11 + 13 # This is the longest sum of consecutive primes that adds to a prime below # one-hundred. # The longest sum of consecutive primes below one-thousand that adds to a prime, # contains 21 terms, and is equal to 953. # Which prime, below one-million, can be written as the sum of the most # consecutive primes? import time import primes # we start by generating the primes below 10**6 lst = primes.Sieve(10**6).listPrimes() def euler_50(): res = 1 # the max length we will found size = len(lst) for i in xrange(size): print lst[i] for j in range(i + res, size): # j will be the position of the last prime in the sum # as the max length we restrict the area we search chunk = lst[i:j + 1] # we sub list the primes we will try to add chunklength = len(chunk) chunktotal = sum(chunk) if chunktotal > 10**6: break