def isTruncPrime(num): num = str(num) if len(num) < 2: # 2,3,5,7 are not considered to be truncatable primes return False for i in range(0,len(num)): # Truncate left to right if (not eulerlib.isPrime(int(num[i:]))): return False for i in range(1,len(num)): # Truncate right to left if (not eulerlib.isPrime(int(num[:i]))): return False return True
def solve(): sieve(1000) qty = 2 # 2 and 5 for p in xrange(3, 1000000, 2): pstr = str(p) if ( all(c in "1379" for c in pstr) and isPrime(p, presieve=False) and all(isPrime(int(pstr[i:] + pstr[:i]), presieve=False) for i in range(1, len(pstr))) ): qty += 1 return qty
def solve(): maxPrimes = 40 maxCoefProd = 41 for b in dropwhile(lambda p: p<=41, primeIter(bound=1000)): for a in xrange(-999, 1000): if a == b+1 or a == b-1: # The quadratic can be factored into (n ± b)(n ± 1) and so will # produce no more than 2 consecutive primes. continue if a*a >= 4*b: bound = b d = sqrt(a*a - 4*b) x1 = (-a+d)/2 x2 = (-a-d)/2 if 0 < x1 < bound: bound = x1 if 0 < x2 < bound: bound = x2 if bound <= maxPrimes: continue n = 1 while isPrime(n*n + a*n + b): n += 1 if n > maxPrimes: maxPrimes = n maxCoefProd = a*b return maxCoefProd
def solve(): sieve(500) P = [Fraction(2 if isPrime(i) else 1, 3) for i in xrange(1, 501)] N = [1 - p for p in P] state = [Fraction(1, 500)] * 500 for primal in [P if c == 'P' else N for c in 'PPPPNNPPPNPPNPN']: state = jump(map(operator.mul, state, primal)) return sum(state)
def solve(): accum = 0 for n1 in primeIter(bound=100000000): n = n1 - 1 for d in xrange(2, int(n**0.5)+1): if n % d == 0 and not isPrime(d + n // d): break else: accum += n return accum
def solve(): import itertools from eulerlib import isPrime # This could be a bit faster, but most of the time is spent in checking if num is a prime or not circular = 1 # 2 is prime for num in range(3,1000000,2): if (isPrime(num)): circular += 1 # Assume the prime is circular # Make sure every rotation is a prime too num = str(num) numL = [num[x] for x in range(0,len(num))] # Number represented as a list of digits for i in range(0,len(numL)): numL.append(numL.pop(0)) # List Rotation rot = int("".join(numL)) # Back into a num you go if (not isPrime(rot)): circular -= 1 # Nope, we were wrong, this prime isn't circular :( break return circular
def solve(): sieve(10**7) new = [(d,d) for d in range(1, 10)] accum = 0 for _ in xrange(12): newer = [] for n,s in new: for d in xrange(10): n2 = n*10 + d s2 = s + d q,r = divmod(n2, s2) if r == 0: newer.append((n2, s2)) if isPrime(q, presieve=False): for e in [1,3,7,9]: m = n2 * 10 + e if isPrime(m, presieve=False): accum += m new = newer return accum
def solve(): import math from eulerlib import isPrime pList = [2] pSums = [2] LIMIT = 1000000 # Get some primes and sum them consecutively i = 1 # Keep track of the index of pSums num = 3 # Keep track of the prime number add = 0 while (add + num < LIMIT): if isPrime(num): pList.append(num) add = pSums[i-1] + num pSums.append(add) i += 1 num += 2 # Find the max consecutive sum starting from each prime maxAdds = 0; maxNum = 0 endLen = len(pSums) pSums.reverse() # Flip the list for prime in pList: for add in pSums[:endLen]: # Summing from the current prime consecutively, # this add is the max prime you can get if isPrime(add): maxNum = add maxAdds = len(pList[pList.index(prime):])-pSums.index(add) endLen = pSums.index(add) # New prime starts must be able to beat the current maxAdds break pSums[pSums.index(add)] -= prime # Subtract prime from each sum to get the sums starting from the next prime # Break if maxAdds is at it's highest possible if maxAdds > len(pList[pList.index(prime):]): break return maxAdds
def solve(): import itertools from eulerlib import isPrime # Bruteforce approach: # 1. Choose a 1st term, check if it's prime, else test next term # 2. Get the permutations of the 1st term # 3. Choose an arithmetic add # 4. Check if 2nd and 3rd terms are prime, else test next add # 5. Check if their permutations, print solution for i in range(1001,3333,2): if not isPrime(i): continue # Get the permutations of the 1st number in the arirthmetic sequence perms = itertools.permutations(str(i), 4) perms = list(perms) for k in range(len(perms)): perms[k] = ''.join(perms[k]) for j in range(2,3333,2): if not isPrime(i+j) or not isPrime(i+2*j): continue if ((str(i+j) in perms) and (str(i+2*j) in perms)): if i != 1487: return(str(i)+str(i+j)+str(i+2*j))
def euler41(): largest = 0 for n in range(3,11): print("Generating permutations for n = ", n, end="") perms = generateStringPermutations( "".join([str(i) for i in range(1, n)])) print("...done.") print("Checking primes...") for p in perms: num = int(p) if isPrime(num): #print(num) largest = max(largest, num) print("done.") print("Largest prime found =", largest)
def primeSets(digits): if len(digits) == 0: return 1 else: accum = 0 d = min(digits) igits = digits - {d} for ds in subsets(igits): if len(ds) == 8: continue arrangements = sum(isPrime(int(''.join(p))) for p in permutations(ds+(d,))) if arrangements != 0: accum += arrangements * primeSets(igits.difference(ds)) return accum
def solve(): for p in allprimes(): pstr = str(p) for d in '012': indices = [i for i,c in enumerate(pstr) if c == d] if indices: for subdex in subsets(indices, nonempty=True): qty = 1 for d2 in range(int(d)+1, 10): s2 = pstr for i in subdex: s2 = s2[:i] + str(d2) + s2[i+1:] if isPrime(int(s2)): qty += 1 if qty == 8: return p
def solve(): import eulerlib import itertools # Create a base pandigital and examine all permutations to see if any of them are prime and large # Can optimize by searching backwards instead (from basePan = 987654321) basePan = "" panDigMax = 0 for n in range(1,10): basePan += str(n) # Concat the n digit string to the base to create a pandigital perms = list(itertools.permutations(basePan)) # All permutations of a pandigital are pandigital for perm in perms: panDig = int("".join(perm)) # Form an int from the iterable if (eulerlib.isPrime(panDig) and panDig > panDigMax): panDigMax = panDig return panDigMax
def solve(): import eulerlib # Maximization of consecutive primes from the quadratic: n^2 + an + b # Where |a| < 1000 and |b| < 1000 and n starts at 0 maxab = 0 maxprimes = 0 bPrimes = eulerlib.PrimeSieve(1000) for a in range(-999,1000,2): # a must be odd to satisify n = 1 case (1+a+b=prime) for b in bPrimes: # b must be pos prime to satisfiy n = 0 case (0+0+b=prime) n = 0 while eulerlib.isPrime(n**2 + a*n + b): n += 1 if (n > maxprimes): maxprimes = n maxab = a*b return maxab
def solve(): maxPrime = 0 maxTerms = 0 primes = list(primeIter(bound=10**6)) for i,p in enumerate(primes): try: accum = sum(primes[i+j] for j in xrange(maxTerms)) except IndexError: break if accum >= 1000000: break for j in xrange(maxTerms, len(primes)-i): accum += primes[i+j] if accum >= 1000000: break if isPrime(accum): maxPrime = accum maxTerms = j+1 return maxPrime
def euler46(): """Solve problem 46 from Project Euler.""" primes = [2,] n = 3 while (True): if isPrime(n): primes.append(n) else: isGoldbach = False # Try to decompose the number according to formula # n = prime + 2x² # n - prime = 2x² # (n - prime)/2 = x² # sqrt((n - prime)/2) = x for prime in primes: x = math.sqrt((n - prime)/2) if x == math.floor(x): # if x is an integer number, n is a valid composite isGoldbach = True break if not isGoldbach: print("Fails Goldbach =", n) break n += 2
def isStrongRightTruncHarshadPrime(n): return isPrime(n) and isRightTruncHarshadNumber(n//10)
def isStrongHarshadNumber(n): return isPrime(n / sumDigits(n)) and isHarshadNumber(n)
def isPrime(num): if num <= primes[-1]: return num in primeset # O(1) else: return eulerlib.isPrime(num) # slower (actually this shouldn't be used given the limit...)
def isPrime(num): if num < LIMIT: return isPrimeTable[num] else: return eulerlib.isPrime(num)
def answers(): for n in count(3): if n % 2 and n % 5 and (n - 1) % A(n) == 0 and not isPrime(n): yield n
# 9 = 7 + 2×1^2 # 15 = 7 + 2×2^2 # 21 = 3 + 2×3^2 # 25 = 7 + 2×3^2 # 27 = 19 + 2×2^2 # 33 = 31 + 2×1^2 # 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 eulerlib import math # Can prove the conjecture by assuming it to be true for each number until it's proven false # n = p + 2*s means that sqrt(s) = sqrt((n-p)/2) must be an integer primes = [2,3,5,7]; n = 9 conjecture = True while (conjecture): n += 2 if (not eulerlib.isPrime(n)): conjecture = False # Assume the conjecture is false # Find the prime p and square s that satisfies the conjecture for p in primes: if (math.sqrt((n - p)/2) % 1 == 0): conjecture = True break else: primes.append(n) print(n)