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 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 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 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 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)