def isRightTruncatable(p, base=10, singleDigit=False):
# test if a given prime p is right-truncatable
if p < base:
return singleDigit
p /= base
while p > base:
if not isPrime(p):
return False
p /= base
return isPrime(p)
def genRightTruncatablePrimes(base=10, singleDigit=False):
# generate right-truncatable primes in specified base
rightTruncatable = list(genPrimes(maxPrime=base-1))
if singleDigit:
for p in rightTruncatable:
yield p
# get a set of digits that can never be added to right-truncatable primes
baseFactors = set(genPrimeFactors(base))
excludeDigits = {0}
while baseFactors:
factor = baseFactors.pop()
digit = factor
while(digit < base):
excludeDigits.add(digit)
digit += factor
# get the list of digits that can be added to right-truncatable primes
allowedDigits = [d for d in range(base) if d not in excludeDigits]
while rightTruncatable:
basePrimes = rightTruncatable
rightTruncatable = list()
for p in basePrimes:
p *= base
for d in allowedDigits:
pTest = p + d
if isPrime(pTest):
rightTruncatable.append(pTest)
yield pTest
def x(i, n, a) : y = n - i b = a[y] if i <= 1 : return 0 if i >= y : s = sum(t[1] for t in b) + (1 if primes.isPrime(y) else 0) else : s = sum(t[1] for t in b if t[0] <= i) return s
def x(i, n, a):
y = n - i
b = a[y]
if i <= 1: return 0
if i >= y:
s = sum(t[1] for t in b) + (1 if primes.isPrime(y) else 0)
else:
s = sum(t[1] for t in b if t[0] <= i)
return s
def countPrimes(a, b):
'''Get count of consecutive primes generated by n^2 + an + b.'''
count = 0
n = 0
while(primes.isPrime(n**2 + a*n + b)):
count += 1
n += 1
return count
def isLeftTruncatable(p, base=10, singleDigit=False):
# test if a given prime p is left-truncatable
pDigits = list(genDigits(p, base))
if len(pDigits) == 1:
return singleDigit
# don't bother testing first digit, assume p is prime
pDigits.pop()
pTest = pDigits.pop(0)
if not isPrime(pTest):
return False
digitVal = base
while pDigits:
pTest += digitVal * pDigits.pop(0)
if not isPrime(pTest):
return False
digitVal *= base
return True
def find_facts(i):
if isPrime(i):
facts.add(i)
return
for p in gPrimes:
j = float(i) / p
if j % 1 == 0:
facts.add(p)
find_facts(int(j))
return
def Euler_41():
''' Returns the largest pandigital prime
'''
# 8 and 9 digits don't work, since sum is multiple of 3
from itertools import permutations
from primes import isPrime
for x in sorted([int(''.join(list(x))) for x in permutations('7654321')], reverse=True):
if isPrime(x):
return x
raise ValueError
def testPrimes(x, lower_limit, minimum):
removeList = []
for i, y in enumerate(x):
if not primes.isPrime(y):
removeList.append(i)
if len(removeList) > 10 - minimum:
return False
else:
for i in range(len(removeList)):
j = removeList[-1 - i]
x.pop(j)
return True
def testPrimes(x, lower_limit, minimum) : removeList = [ ] for i,y in enumerate(x) : if not primes.isPrime(y) : removeList.append(i) if len(removeList) > 10-minimum : return False else : for i in range(len(removeList)) : j = removeList[-1 - i] x.pop(j) return True
def reducedFraction(t):
num, denom = t[0], t[1]
#if prime_cache.isPrime(num) or prime_cache.isPrime(denom) :
if primes.isPrime(num) or primes.isPrime(denom):
return t
else:
pn = primes.primeFactors(num)
pd = primes.primeFactors(denom)
i, j = 0, 0
remove = []
while i < len(pn) and j < len(pd):
if pn[i] < pd[j]: i += 1
elif pn[i] > pd[j]: j += 1
else:
remove.append((i, j))
i += 1
j += 1
L = len(remove)
for j in range(L):
t = remove.pop()
pn.pop(t[0])
pd.pop(t[1])
return (product(pn), product(pd))
def reducedFraction(t) : num, denom = t[0], t[1] #if prime_cache.isPrime(num) or prime_cache.isPrime(denom) : if primes.isPrime(num) or primes.isPrime(denom) : return t else : pn = primes.primeFactors(num) pd = primes.primeFactors(denom) i, j = 0, 0 remove = [] while i < len(pn) and j < len(pd) : if pn[i] < pd[j] : i += 1 elif pn[i] > pd[j] : j += 1 else : remove.append( (i, j) ) i += 1 j += 1 L = len(remove) for j in range(L) : t = remove.pop() pn.pop(t[0]) pd.pop(t[1]) return ( product(pn) , product(pd) )
def euler60(upper) : import primes import collections print "Testing up to %d" % upper p = primes.primes(upper) d = collections.defaultdict(list) base = 10 for i in xrange(1, len(p)) : pi = p[i] while pi > base : base *= 10 print >> sys.stderr, pi, len(d), "\r", base2 = base for j in xrange(i+1, len(p)) : pj = p[j] while pj > base2 : base2 *= 10 pipj = pi*base2 + pj if primes.isPrime(pipj) : pjpi = pj*base + pi if primes.isPrime(pjpi) : d[pi] += [pj] d[pj] += [pi] testAllKeys(d)
def genLeftTruncatablePrimes(base=10, singleDigit=False):
# generate left-truncatable primes in specified base
leftTruncatable = list(genPrimes(maxPrime=base-1))
if singleDigit:
for p in leftTruncatable:
yield p
digitVal = 1
while leftTruncatable:
basePrimes = leftTruncatable
leftTruncatable = list()
digitVal *= base
for p in basePrimes:
for d in range(1, base):
p += digitVal
if isPrime(p):
leftTruncatable.append(p)
yield p
def euler27():
"""Find the coefficients for f(n) = n^2 + an + b for -1000 < a < 1000 and -1000 < b < 1000
that produces primes for n = 0 through n = m for the largest m."""
# for n = 0, f(n) = b, so b must be an odd prime.
# for n = 1, f(n) = 1 + a + b, so a must be odd and no smaller than -(b-2)
# (possible exceptions for f(n) = 2 are not possible with n > 1)
best_n = -1
for b in primes.primesBelow(1000):
for a in xrange(-(b-2), 1000, 2):
for n in count():
if not primes.isPrime(n * n + a * n + b):
break
if best_n < n-1:
best_n = n-1
best_a = a
best_b = b
debug("{} primes produced by a = {}, b = {}", n, a, b)
return best_a * best_b
def euler141() : ## [3,102,130,312,759,2496,2706,3465,6072,6111,8424,14004,16005,36897,37156,92385,98640,112032,117708,128040,351260,740050]) : s = set() for sqr in xrange(2, 1000*1000) : if primes.isPrime(sqr) : continue i = sqr*sqr print sqr, i, "\r", f = primes.factors(sqr) sp = specialFactors.specialFactors(f, sqr) for r in sp : x = r * (i - r) cub = CubeRoot(x) if cub : q, r2 = divmod(i, cub) if r == r2 : a = [r, q, cub] print sqr, i, a s.add(i) break print sorted(s) print sum(s)
def euler41(base=10, skipImpossible=True):
foundPrime = False
if skipImpossible:
nStart = base-3
else:
nStart = base-1
for n in range(nStart, 1, -1):
for pd in genPandigitalNums(n, base=base, skipImpossible=skipImpossible):
if isPrime(pd):
foundPrime = True
break
if foundPrime:
break
if not foundPrime:
print("No prime pandigital numbers (base %d)" % base)
return None
elif base == 10:
print('%d is the largest pandigital prime (base 10)' % pd)
else:
from digit_math import intToStr
pdStr = intToStr(pd, base=base)
print('%s is the largest pandigital prime (base %d)' % (pdStr, base))
return pd
c = 7
cIncrement = 14
d = 9
dIncrement = 16
while True:
yield a, b, c, d
a += aIncrement
aIncrement += 8
b += bIncrement
bIncrement += 8
c += cIncrement
cIncrement += 8
d += dIncrement
dIncrement += 8
if "__main__" == __name__:
diags = 1
primes = 0
for i, nextDiagonals in enumerate(NextDiagonals()):
diags += 4
for d in nextDiagonals:
if isPrime(d):
primes += 1
if float(primes) / diags < 0.1:
print (1 + i) * 2 + 1
break
def compatible(primeset, newprime):
newprime = str(newprime)
primeset = map(str, primeset)
return all(isPrime(int(newprime+oldprime)) for oldprime in primeset) and\
all(isPrime(int(oldprime+newprime)) for oldprime in primeset)
import psyco
psyco.full()
import prime_cache
import primes
squares, cubes, fourth = [], [], []
upper = 50 * 1000 * 1000
for i in range(2, int(upper ** 0.5) + 1):
if primes.isPrime(i):
sq = i * i
if sq < upper:
squares.append(sq)
else:
break
tr = i * sq
if tr < upper:
cubes.append(tr)
fo = i * tr
if fo < upper:
fourth.append(fo)
# print squares
# print cubes
# print fourth
s = set()
for x4 in fourth:
remainder4 = upper - x4
from permutations import next_permutation
from primes import isPrime
for n in range(1234, 10000):
nums = [int("".join(s)) for s in list(next_permutation(list(str(n))))]
primeNums = [i for i in nums if isPrime(i)]
if len(primeNums) == 3 and (primeNums[2] - primeNums[1]) == (primeNums[1] - primeNums[0]):
print "".join(str(p) for p in primeNums)
break
return False
i += 1
return True
n0 = 30000
n1 = 500000
t0 = time.perf_counter()
# Numba function:
a = [p for p in range(1, n1) if isPrime(p)]
t1 = time.perf_counter()
# Cython function:
b = [p for p in range(1, n1) if primes.isPrime(p)]
t2 = time.perf_counter()
print("Numba time:", round((t1-t0)*1000, 1), "ms")
print("Cython time:", round((t2-t1)*1000, 1), "ms")
"""Numba vs Cython
Made with:
Python 3.4.3
Numba 0.18.2
Cython 0.22
Pretty consistent results (30000 loops each):
Python time: ~115ms
Numba time: ~9ms
__author__ = "adam"
import primes
from math import sqrt
def isGoldbach(x):
for i in primes.numpyPrimes(x):
rest = sqrt((x - i) / 2)
if int(rest) - rest == 0:
return True
return False
n = 33
while True:
n = n + 2
while primes.isPrime(n):
n = n + 2
if not isGoldbach(n):
print n
break
def testSpecialFactors():
for i in range(4, 100):
if not primes.isPrime(i):
f = primes.factors(i)
sp = specialFactors(f, i)
print i, sp
def isPr(x):
if x < 100000000:
return pr[x]
else:
return primes.isPrime(x)
import primes, os
sum = 0
for i in range(0, 2000000):
if i % 2 == 1 and primes.isPrime(i):
sum = sum + i
print(i)
os.system("clear")
print(sum)
import primes def getTruncated(n): out = [] for i in range(len(str(n))): out.append(int(str(n)[:len(str(n))-i])) out.append(int(str(n)[i:])) return out s = 0#8897 i = primes.getIndexOf(7)+1 l = [] while len(l) < 11: j = primes.getPrimeAt(i) if all([primes.isPrime(x) for x in getTruncated(j)]): s+=j l.append(j) print j, s i+=1 #3797 8897
def genCirclePrimes(maxPrime=float('inf'), base=10):
# get the 1-digit circular primes
for d in range(2, base):
if isPrime(d):
yield d
# get a set of digits that can never be in multi-digit circular primes
baseFactors = set(genPrimeFactors(base))
excludeDigits = {0}
while baseFactors:
factor = baseFactors.pop()
digit = factor
while(digit < base):
excludeDigits.add(digit)
digit += factor
# get the list of digits that can be in multi-digit circular primes
allowedDigits = [d for d in range(base) if d not in excludeDigits]
numAllowed = len(allowedDigits)
lastAllowed = numAllowed - 1
numDigits = 2
digits = [0] * numDigits
num = allowedDigitsToInt(digits, allowedDigits, base)
while num <= maxPrime:
# check if num represents a circular prime
if isPrime(num):
# check if num is circular
shiftDigits = [digits[-1]] + digits[:-1]
if shiftDigits == digits:
# num is automatically circular
yield num
else:
circlePrimes = { num }
shiftNum = allowedDigitsToInt(shiftDigits, allowedDigits, base)
while isPrime(shiftNum):
circlePrimes.add( shiftNum )
if len(circlePrimes) == numDigits:
for p in circlePrimes:
yield p
break
shiftDigits = [shiftDigits[-1]] + shiftDigits[:-1]
shiftNum = allowedDigitsToInt(shiftDigits, allowedDigits, base)
# increment digits, ensuring that the smallest digit is digits[0]
j = numDigits - 1
while digits[j] == lastAllowed:
if j == 0:
numDigits += 1
digits = [0] * numDigits
j = None
break
digits[j] = digits[0] + 1
j -= 1
if j is not None:
if j == 0:
digits = [digits[0] + 1] * numDigits
else:
digits[j] += 1
num = allowedDigitsToInt(digits, allowedDigits, base)
from primes import isPrime
highest = 0
highestAB = 0
for a in range(-999, 1000):
for b in xrange(-999, 1000):
n = 0
while isPrime(n ** 2 + a * n + b):
n += 1
if n > highest:
highest = n
highestAB = a * b
print highestAB
__author__ = 'adam'
import primes
from math import sqrt
def isGoldbach(x):
for i in primes.numpyPrimes(x):
rest = sqrt((x-i)/2)
if int(rest) - rest == 0:
return True
return False
n=33
while True:
n=n+2
while (primes.isPrime(n)):
n=n+2
if not isGoldbach(n):
print n
break
import primes def rotate(n, x): return int(str(n)[x:] + str(n)[0:x]) def getRotations(n): return [rotate(n,i) for i in range(len(str(n)))] print sum([1 for i in primes.getPrimesBetween(2,101) if all([primes.isPrime(r) for r in getRotations(i)])])
import specialFactors import primes j = 4 max_so_far = -1 k = -1 while 1 : if not primes.isPrime(j) : f = primes.factors(j) sp = specialFactors.specialFactors(f, j) L = len(sp) if L > max_so_far : pf = primes.primeFactors(j) max_so_far, k = L, j print k, max_so_far, pf if L > 1000 : break print j, L, "\r", j += 1 print print k, max_so_far
def testSpecialFactors() : for i in range(4, 100) : if not primes.isPrime(i) : f = primes.factors(i) sp = specialFactors(f, i) print i, sp
import psyco
psyco.full()
import prime_cache
import primes
squares, cubes, fourth = [], [], []
upper = 50 * 1000 * 1000
for i in range(2, int(upper**0.5) + 1):
if primes.isPrime(i):
sq = i * i
if sq < upper:
squares.append(sq)
else:
break
tr = i * sq
if tr < upper:
cubes.append(tr)
fo = i * tr
if fo < upper:
fourth.append(fo)
#print squares
#print cubes
#print fourth
s = set()
for x4 in fourth:
remainder4 = upper - x4
# whelp as usual with primes, there's no easy way to deal with this lol
import sys
sys.path.append("..")
import math
import primes
# so this is too memory-intensive for dunkhut to handle.
# ...maybe, since we're not actually using that many primes, trial division
# would actually be better?
#limit = 100000000
#primesList = primes.getPrimes(limit, "log")
#print "primes calculated..."
#sideLengthLimit = 10000
primesList = [3, 5, 7]
square = 9
while float(len(primesList)) / (((
(math.sqrt(square)) - 1) * 2) + 1) > 0.1: # \
# and square < sideLengthLimit ** 2:
sideLength = math.sqrt(square) + 1
for i in range(1, 5):
square = int(square + sideLength)
if primes.isPrime(square):
primesList.append(square)
print math.sqrt(square)
print float(len(primesList)) / ((((math.sqrt(square)) - 1) * 2) + 1)
print math.sqrt(square)
#if sideLengthLimit ** 2 == square:
# print "which is the side length limit..."
import sys
sys.path.append('./utils')
from primes import isPrime
#initial parameters for diagnol wrap
diagnol = 1.0
primes_on_diag = 0.0
side_len = 1
curren_int = 1
#begins with diagnol ratio
#artifact of necesity
percent_prime_diagnol = 1
#each iteration wraps one new layer around
#stops once desired percentage reached
while percent_prime_diagnol > .1:
#each layer increases
side_len += 2
to_next_diagnol = side_len - 1
diagnol += 4.0
for i in range(4):
curren_int += to_next_diagnol
if isPrime(curren_int):
primes_on_diag += 1.0
percent_prime_diagnol = primes_on_diag / diagnol
#final answer
print(side_len)
#!/usr/bin/python
from factors import factorsOfGenerator
from primes import isPrime
primes = []
for x in factorsOfGenerator(600851475143):
if x[0] == 1:
pass
for y in x:
if isPrime(y):
primes.append(y)
print primes[-1]
#!/usr/bin/python from primes import isPrime assert isPrime(13) assert isPrime(23) assert isPrime(31) assert not isPrime(1024) assert not isPrime(101*63423) from primes import monteCarloIsPrime assert monteCarloIsPrime(13) assert monteCarloIsPrime(23) assert monteCarloIsPrime(31) assert not monteCarloIsPrime(1024) assert not monteCarloIsPrime(101*63423) assert not monteCarloIsPrime(48039758943759842378954983) from primes import getAllPrimesBelow assert 0 == len(getAllPrimesBelow(2)) primes= [2] value = getAllPrimesBelow(3)
import primes def replace(a, b, n): return int(str(n).replace(str(a), str(b))) done = False for p in primes.primes: for i in list(set(str(p))): l = [] for x in range(10): t = replace(i, x, p) if primes.isPrime(t) and len(str(t)) == len(str(p)): l.append(t) if len(set(l)) == 7: print p, list(set(l)) done = True break if done: break
