def prime_pair_sets(): """Input: None. Output: The lowest sum for five primes for which the concatenation of any two is primes.""" ps = primes(10000) for i in range(len(ps)): for j in range(i + 1, len(ps)): if not is_prime(cat([ps[i], ps[j]])): continue if not is_prime(cat([ps[j], ps[i]])): continue for k in range(j + 1, len(ps)): if not is_prime(cat([ps[i], ps[k]])): continue if not is_prime(cat([ps[j], ps[k]])): continue if not is_prime(cat([ps[k], ps[i]])): continue if not is_prime(cat([ps[k], ps[j]])): continue for l in range(k + 1, len(ps)): if not is_prime(cat([ps[i], ps[l]])): continue if not is_prime(cat([ps[j], ps[l]])): continue if not is_prime(cat([ps[k], ps[l]])): continue if not is_prime(cat([ps[l], ps[i]])): continue if not is_prime(cat([ps[l], ps[j]])): continue if not is_prime(cat([ps[l], ps[k]])): continue for m in range(l + 1, len(ps)): if not is_prime(cat([ps[i], ps[m]])): continue if not is_prime(cat([ps[j], ps[m]])): continue if not is_prime(cat([ps[k], ps[m]])): continue if not is_prime(cat([ps[l], ps[m]])): continue if not is_prime(cat([ps[m], ps[i]])): continue if not is_prime(cat([ps[m], ps[j]])): continue if not is_prime(cat([ps[m], ps[k]])): continue if not is_prime(cat([ps[m], ps[l]])): continue return sum([ps[i], ps[j], ps[k], ps[l], ps[m]])
def coefficientsMaxPrimes(coeff_limit): max_n_primes = 40 # known result from Euler max_a = 1 # known result from Euler max_b = 41 # known result from Euler for b in primes(): if b <= 41: continue # Euler's result is better if b > coeff_limit: break # to generate at least `max_n_primes` primes, a should start from here start = -(max_n_primes + b // max_n_primes) # a should be odd if start % 2 == 0: start -= 1 for a in range(start, 0, 2): n_primes = 0 while is_prime(n_primes**2 + a * n_primes + b): n_primes += 1 if n_primes > max_n_primes: max_n_primes = n_primes max_a = a max_b = b return max_a, max_b
def main(): prime_numbers = primes(1000) num, num_of_div, num_of_div_sofar = 3, 2, 0 while num_of_div_sofar <= 500: num += 1 next_num = num if next_num % 2 == 0: next_num /= 2 tmp_num_of_div = 1 for prime in prime_numbers: if prime * prime > next_num: tmp_num_of_div *= 2 break expon = 1 while next_num % prime == 0: expon += 1 next_num /= prime if expon > 1: tmp_num_of_div *= expon if next_num == 1: break num_of_div_sofar = num_of_div * tmp_num_of_div num_of_div = tmp_num_of_div print(num * (num - 1) / 2)
def lpfactor(xx): """ Gives the largest prime factor of xx. """ pp = primes(int(sqrt(xx))) for ii in pp[::-1]: if xx % ii == 0: return(ii)
def max_factor(N): max_factor = None limit = floor(sqrt(N)) for p in primes(): if N % p == 0: max_factor = p if p > limit: return max_factor
def truncatable_primes(): """Input: None. Output: The sum of all truncatable prime numbers.""" result = [] ps = [i for i in primes(1000000) if i > 11] for p in ps: if all_primes(truncations(p)): result.append(p) if len(result) == 11: return sum(result)
def prime_permutations(): """Input: None. Output: The concatenation of three 4-digit numbers that are prime permutations.""" ps = primes(10000) ps = set(ps[ps > 1487]) for p in ps: if p + 3330 in ps and p + 6660 in ps: if is_permutation(p, p + 3330) and is_permutation(p, p + 6660): return cat([p, p + 3330, p + 6660])
def problem(): """ >>> problem() 6857 """ number = 600851475143 limit = int(sqrt(number)) res = 1 for prime in takewhile(lambda x: x <= limit, primes()): if number % prime == 0: res = prime return res
def main(): primes = set([p for (_, p) in zip(range(10000), euler.primes())]) max_n = 0 aa = bb = 0 for a in range(-999, 1000): for b in range(-999, 1000): n = 0 while n*n + n*a + b in primes: n += 1 if n > max_n: max_n = n aa = a bb = b print(aa, bb, aa*bb)
def findCircular(n): ''' Find all circular primes below n. ''' primeList, primeSieve = primes(n) # 2 and 5 will be skipped circleCount = 2 for p in primeList: # If any even nums then at least 1 permutation cannot be prime if any(n % 2 == 0 or n == 5 for n in digitize(p)): continue if all(primeSieve[(r - 3) / 2] for r in rotate(p)): circleCount += 1 return circleCount
def longest_prime_chain(aa, bb, pmax = 1000): """ Generates prime chains of the form n^2 + an + b with a < |aa| and b < |bb|. The output are parameters a,b generating the longest chain. """ plist = primes(pmax) tmp = 0 out = 0, 0 for i in range(-aa, aa): for j in range(-bb, bb): k = j n = 0 while k in plist: n += 1 k = n * n + i * n + j if n > tmp: tmp = n out = i, j return out
from euler import primes, fac def S(p): if p == 5: return 4 return (mfac(p - 6, p) * -45) % p def lazyS(p): return sum(fac(p - k) for k in range(1, 6)) % p def mfac(k, p): r = 1 for f in range(1, k + 1): r = (r * f) % p return r ps = primes(int(1e2)) a = 0 for p in ps: if p >= 5: k = S(p) print(mfac(p - 6, p), (-fac(p - 1) / fac(5)) % p, p) a += k print(a)
from euler import primes from math import log # Generalized Hamming Count def ghc(n, ps): if not ps: return 1 else: p = ps[-1] k = int(log(n, p)) # Important to not do an integer division here! return sum(ghc(n/(p**i), ps[:-1]) for i in range(0,k+1)) print(ghc(1e9, primes(100)))
Considering quadratics of the form: n^2 + an + b, 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 euler import is_prime, primes max_count = 40 max_ab = 1 * 41 def f(n, a, b): return is_prime(n**2 + a * n + b) # b must be prime (consider n = 0) for b in primes(1000): # a must be odd (consider n = 1) for a in range(-999, 1000, 2): if all(f(x, a, b) for x in reversed(range(max_count))): while True: if f(max_count + 1, a, b): max_count += 1 result = a * b else: break
import euler # from itertools import permutations # 3 7 109 673 p = euler.primes(1000000)[1:] print len(p) def chk(a, b): return int(str(a) + str(b)) in p and int(str(b) + str(a)) in p # Add all prime pairs that "chk" True to set s. s = set() ln = 200 for i in range(ln): for j in range(i + 1, ln): if chk(p[i], p[j]): s.add((p[i], p[j])) ##for i, el in enumerate(s): ## print el ## if i > 10: break res = [[n] for n in p[:ln]] # start with list of lists, each list is 1 prime # check all prime pairs up to certain limit # add 3rd, add 4th, add 5th, return min of sum for i in range(4): print "loop", i
import euler primes = euler.primes(1000, 9999) def is_prime(n): return n in primes def is_permutation(a, b): l = [0 for i in range(10)] while a: l[a % 10] += 1 l[b % 10] -= 1 a = a // 10 b = b // 10 return all(x == 0 for x in l) assert is_permutation(1487, 4817) for i in range(len(primes)): for j in range(i + 1, len(primes)): a = primes[i] b = primes[j] c = 2 * b - a if is_prime(c) and is_permutation(a, b) and is_permutation(a, c): print('find permutation (%d, %d, %d)' % (a, b, c))
#!/usr/bin/env python """ The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17. Find the sum of all the primes below two million. """ from euler import primes import time st = time.time() numbers = primes(2000000) result = 0 for i in numbers: result += i print result print "Time taken: %s" % str(time.time() - st)
from itertools import permutations from euler import primes from timeit import default_timer as timer divisors = primes(18) def follows_property(n): for k in range(7): if int(n[k + 1:(k + 4)]) % divisors[k] != 0: return False return True sum = 0 start = timer() for combo in permutations([str(x) for x in range(10)]): num = ''.join(combo) if follows_property(num): sum += int(num) elapsed_time = (timer() - start) * 1000 # s --> ms print("Found %d in %r ms." % (sum, elapsed_time))
from euler import primes, numDigits """ p1,p2,inc p2 | inc*k + p1 inc*k + p1 = 0 (mod p2) inc*k = -p1 (mod p2) inc*k = p2 - p1 (mod p2) k = (p2 - p1) * inc^-1 (mod p2) """ BOUND=int(1e6) ps = primes(BOUND + 100) # Based on Wikipedia source code on Extended Euclidean Algorithm # computes the multiplicative inverse of a in the field Z/nZ # The internets also tell me that you can use the Chinese Remainder Theorem # which I should probably read up on def modInverse(a, n): t = 0 r = n newt = 1 newr = a while newr != 0: quot = r // newr (t, newt) = (newt, t - quot * newt) (r, newr) = (newr, r - quot * newr) if t < 0: return t + n return t ans = 0 for i in range(2, len(ps)):
import fractions import euler limit = 15499 / 94744.0 print "Limit:", limit # limit = 4 / 10.0 primes = euler.primes() def check(x): count = 0 for i in xrange(x): if fractions.gcd(i, x) == 1: count += 1 return count def check2(x): count = 1 factors = [] for prime in primes: if 2 * prime > x: break if x % prime == 0: count += x / prime count -= 1 factors.append(prime) print factors for i in range(len(factors) - 1): for b in range(i + 1, len(factors)): c = factors[i] * factors[b] if x % c == 0:
import time st = time.time() def truncate_left(n): for i in xrange(1,len(str(n))): if not is_prime(int(str(n)[i:len(str(n))])): return False return True def truncate_right(n): for i in xrange(1,len(str(n))): if not is_prime(int(str(n)[0:-i])): return False return True primes = primes(1000000) total = 0 result = [] for i in primes: if i > 7: if truncate_left(i) and truncate_right(i): result.append(i) print "Result: " + str(result) print "Total: " + str(sum(result)) print "Time taken: %s" % str(time.time() - st)
from euler import primes s = primes(2000000) primeList = s.basicSieve() total = sum([i for i in range(0, 2000000) if primeList[i]]) print(total)
def main(): print(sum(primes(2000000)))
#!/usr/bin/env python """ 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 euler import ispandigital, primes import time st = time.time() primes = primes(10000000) total = 0 for prime in primes: if ispandigital(prime, len(str(prime))): if prime > total: total = prime print total print "Time taken: %s" % str(time.time() - st)
""" A unit fraction contains 1 in the numerator. The decimal representation of the unit fractions with denominators 2 to 10 are given: 1/2 = 0.5 1/3 = 0.(3) 1/4 = 0.25 1/5 = 0.2 1/6 = 0.1(6) 1/7 = 0.(142857) 1/8 = 0.125 1/9 = 0.(1) 1/10 = 0.1 Where 0.1(6) means 0.166666..., and has a 1-digit recurring cycle. It can be seen that 1/7 has a 6-digit recurring cycle. Find the value of d < 1000 for which 1/d contains the longest recurring cycle in its decimal fraction part. """ # from Fermat's little theorem, the period of the repeating decimal of 1 / p # is equal to the order of 10 modulo p. If 10 is a primitive root modulo p, # the period is equal to p - 1; if not, the period is a factor of p - 1. from euler import multiplicative_order, primes result = max(primes(1000)[4:], key=lambda x: multiplicative_order(10, x))
import euler from itertools import permutations, combinations from time import time # 3 7 109 673 # 23 311 677 827 # https://coderwall.com/p/utwriw # Miller Rabin https://gist.github.com/bnlucas/5857478 t = time() ##p = euler.primes(10**6) ##nums = p[1:167] p = euler.primes(15000000) nums = p[1:235] print "p done" m = {} def chk(a, b): if (a, b) in m: return m[(a, b)] else: m[(a, b)] = int(str(a) + str(b)) in p and int(str(b) + str(a)) in p return m[(a, b)] def solve(): for a in nums: for b in nums[nums.index(a) + 1:]:
#!/usr/bin/env python # Copyright (c) 2008 by Steingrim Dovland <*****@*****.**> from euler import primes # The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17. # # Find the sum of all the primes below two million. numbers = primes(2*1000*1000) print sum(numbers)
def stPrime(n): for index, pr in enumerate(primes(), 1): if index == n: return pr
How many circular primes are there below one million? """ import time st = time.time() from euler import primes, is_prime def rotate_seq (seq): for i in range (len (seq)): yield seq[i:] + seq[:i] def is_circular(n): for i in rotate_seq(str(n)): if not is_prime(i): return False return True numbers = primes(1000000) result = 0 for i in numbers: if is_circular(i): result += 1 print result print "Time taken: %s" % str(time.time() - st)
from euler import primes digtry = 1000 maxprimes = [] while len(maxprimes) < 8: primelist = primes(digtry) for n in range(1, 10): for i in range(digtry / 10, digtry): i = str(i) strloop = len(i) primecheck = [] for j in range(0, strloop): p = int(i[:j] + str(n) + i[j + 1:]) if p in primelist: primecheck.append(p) if len(primecheck) > len(maxprimes): maxprimes = primecheck print maxprimes digtry *= 10
for c in getCombinations(num): ret.append(replace(num, c)) return ret def replace(num, pos): ret = [] if 0 in pos: lista = range(1, 10) else: lista = range(10) for n in lista: aux = list(str(num)) for p in pos: aux[p] = str(n) ret.append(int(''.join(aux))) return ret for p in primes(10**6): stop = False for l in getReplaced(p): if numPrimes(l) == 8: print l stop = True break if stop: break #121313
from euler import primes # Computed answer for 100000 and number of primes is 183 PRIME_CAP = 1000000 # Compute all primes below the cap primeList, _ = primes(PRIME_CAP) def solve(): # Idea: For each prime, check for consecutive sequences # of primes that sum to it answer = 0 maxConsec = 0 for prime in reversed(primeList): consec = 0 # Number of consecutive primes pSum = 0 # Sum so far start = 0 # Start index of the sum for i, p in enumerate(primeList): if p * (maxConsec - consec) >= prime: break pSum += p consec += 1 while pSum > prime: pSum -= primeList[start] start += 1 consec -= 1 if pSum == prime: if consec > maxConsec: maxConsec = consec answer = prime break return answer, maxConsec
import euler import itertools print(list(itertools.islice(euler.primes(), 10000, 10001)))
from euler import primes, isPrime from itertools import permutations def get_permutations(num): aux=str(num) for i in permutations(aux): yield ''.join(i) primes=[x for x in primes(10000) if x>=1000] for p in primes: current=[] for permut in get_permutations(p): perm=int(permut) if isPrime(perm) and perm not in current: current.append(perm) if len(current)==3: current=sorted(current) if current[1]-current[0]==current[2]-current[1]: print str(current[0])+str(current[1])+str(current[2]) #296962999629
import math from euler import primes MAX_NUM = 7654321 PRIME_LIST = primes(int(math.sqrt(MAX_NUM)) + 1)[0] DIGITS = set(xrange(1,8)) def isPrime(i): return not any(i % p == 0 for p in PRIME_LIST) def permuteInts(s): def _permute(aSet, acc): if not aSet: yield acc for c in aSet: for perm in _permute(aSet.difference(set((c,))), acc*10 + c): yield perm return _permute(set(s), 0) print(max(p for p in permuteInts(DIGITS) if isPrime(p)))
""" import time st = time.time() from euler import primes, is_prime def rotate_seq(seq): for i in range(len(seq)): yield seq[i:] + seq[:i] def is_circular(n): for i in rotate_seq(str(n)): if not is_prime(i): return False return True numbers = primes(1000000) result = 0 for i in numbers: if is_circular(i): result += 1 print result print "Time taken: %s" % str(time.time() - st)
from euler import primes, pan maxnum = 999999999 minnum = 0 primelist = primes(maxnum) for i in primelist: if pan(i) == True: print i
#!/usr/bin/env python """ By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13. What is the 10001st prime number? """ import time st = time.time() from euler import primes numbers = primes(200000) print numbers[10000] print "Time taken: %s" % str(time.time() - st)
""" The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17. Find the sum of all the primes below two million. """ from euler import primes result = sum(primes(2 * 10**6))
def problem(): """ >>> problem() 104743 """ print(next(islice(primes(), 10000, 10001)))
#!/usr/bin/env python # Copyright (c) 2008 by Steingrim Dovland <*****@*****.**> from euler import primes # By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can # see that the 6th prime is 13. # # What is the 10001st prime number? print primes(1000*1000)[10000]
from euler import choose, squarefree, primes N = 51 ps = primes(int(choose(N-1,(N-1)//2)**.5)) print("got primes") sfrees = set() for n in range(0,N): for k in range(0,(n+3)//2): coeff = choose(n,k) if squarefree(coeff,ps): sfrees.add(coeff) print(sum(sfrees))
import math import euler array = euler.primes(2, 1000000) def prime_factor(n, d): factor = 0 while n % d == 0: n = n / d factor = factor + 1 return factor def divisible_number(n): total = 1 for d in array: if d > n: break; factor = 1 while n % d == 0: n = n / d factor = factor + 1 total = total * factor return total value = 1 i = 1 while divisible_number(value) <= 500: i = i + 1 value = i * (i + 1) / 2 print(value)
from euler import rational, primes, product def ways(n): w = 0 for a in range(1, 2*n + 1): if (rational(1, n) - rational(1, a)).num == 1: w += 1 return w ps = primes(100) min_val = float("inf") for n in range(1, len(ps)): for k in range(0,4): for m in range(0,4): N = product(ps[:n]) * (2**k) * (3**m) if N < min_val: ws = ways(N) if ws > 1000: min_val = N print(min_val, ws) print(min_val)
import euler import itertools print(sum(itertools.takewhile(lambda x: x < 2000000, euler.primes())))
""" The prime 41, can be written as the sum of six consecutive primes: 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? """ from itertools import count from euler import primes p = primes(10 ** 6) set_p = set(p) def f(): # first find an upper bound on n n = 1 while sum(p[:n]) < 10 ** 6: n += 1 while True: for i in count(): sum_p = sum(p[i:n + i]) if sum_p < 10 ** 6: if sum_p in set_p: return sum_p else: break n -= 1
from euler import primes, gcd, radical N = 120000 ps = primes(N) rad = [0] + [radical(n, ps) for n in range(1, N+1)] ans = 0 relradsorted = sorted(list(range(1, N)),key=lambda x: rad[x]/x) radsorted = sorted(list(range(1, N)),key=lambda x: rad[x]) m = 1000 for c in relradsorted: if rad[c]/c > 1/2: break for a in radsorted: if a > c//2-1: continue if rad[a] > (c/rad[c]): break b = c - a if gcd(a,b) == gcd(a,c) == gcd(b,c) == 1: if rad[a]*rad[b]*rad[c] < c: ans += c print(ans)
import sys,itertools from euler import primes num = int(sys.argv[1]) print(next(itertools.islice(primes(), num-1, num)))
import euler # all other digit conbinatons except (1 .. 4) and (1 ... 7) can be divided evenly by 3 for i in reversed(euler.primes(2, 7654321)): if euler.is_pandigital(i, 1, 7): print('largest pandigital prime is %d' % i) break
import math import euler primes = euler.primes(2, 1000000) cache = {x : True for x in primes} def is_prime(n): return n in cache def digit_len(n): l = 0 while n: n = n // 10 l += 1 return l def is_circular_prime(n): digits = digit_len(n) scale = int(math.pow(10, digits - 1)) for i in range(0, digits): unit = n % 10 n = unit * scale + n // 10 if not is_prime(n): return False return True assert is_circular_prime(197) assert is_circular_prime(97) result = [x for x in primes if is_circular_prime(x)] print(result) print(len(result))
import sys,itertools from euler import primes num = int(sys.argv[1]) print(sum(itertools.takewhile(lambda p: p < num, primes())))
def nth_prime(n): for i, prime in enumerate(p for p in primes()): if i + 1 == n: return prime
# Project Euler Problem 60 import time import euler from math import floor, log10 startTime = time.clock() # Setting this rather arbitrarily; not sure the best number to use. PRIME_LIMIT = 10000 primeList = euler.primes(PRIME_LIMIT) minimumSum = PRIME_LIMIT**2 primePairsSet = set() def getPair(p1, p2): p1Val = floor(log10(p1)) + 1 p2Val = floor(log10(p2)) + 1 return (p1 * (10**p2Val) + p2, p2 * (10**p1Val) + p1) def isConcatPrimePair(p1, p2): pair = getPair(p1, p2) if pair[0] in primePairsSet: if pair[1] in primePairsSet: return True else: if euler.isPrime(pair[0]) and euler.isPrime(pair[1]): primePairsSet.update(pair) return True
""" 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? """ from euler import primes primes4 = set(primes(10000)[len(primes(1000)):]) # 4-digit primes for p in primes4: p1 = 3330 + p p2 = 3330 + p1 if p1 in primes4 and p2 in primes4: if sorted(str(p1)) == sorted(str(p2)) == sorted(str(p)): if p != 1487: result = p2 + p1 * 10 ** 4 + p * 10 ** 8 break
from euler import isPrime, range_infinite, primes primes = primes(10**5) for i in range_infinite(35, 2): if not isPrime(i): flag = True for p in primes: if p < i: found = False for j in range_infinite(1, 1): if p + 2 * j * j > i: break elif p + 2 * j * j == i: found = True break if found: break else: flag = False break if not flag: print i break #5777
from euler import isPrime, primes from itertools import takewhile candidates = set() upto = int(100000001 / 2) setOfPrimes = set(takewhile(lambda x: x <= upto, primes())) # for d in xrange(1, upto): # pass # if isPrime(int(d+30/d)): # candidates.add(d) # for i in xrange(2, upto): # for d in xrange(i, upto, i): # if d in candidates: # if not isPrime(int(d+30/d)): # candidates.remove(d)