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