#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from EratosthenesSieve import *
import itertools
upperLimit=10**6
patternFamilySize=8
eratosthenesSieve=EratosthenesSieve()
eratosthenesSieve.growToNumber(upperLimit)
sieve=eratosthenesSieve.sieve()
sieveSet=set(sieve)
length=len(sieve)
#print sieve, length
def allSubsets(iterable):
result=[[]]
for i in range(1, len(iterable)+1):
result+=list(itertools.combinations(iterable, i))
return result
def emitPatterns(numberInText, digit):
result=[]
digitOffsetList=[]
for (index, currentDigit) in enumerate(numberInText):
if digit==currentDigit:
digitOffsetList.append(index)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from Factorize import *
from EratosthenesSieve import *
import math
upperLimit = 10 ** 7
sieve = EratosthenesSieve()
sieve.growToNumber(2 * int(math.ceil(math.sqrt(upperLimit))))
primeList = list(sieve.sieve())
# print primeList, len(primeList)
hashSort = lambda s: "".join(sorted([c for c in str(s)]))
results = []
for prime1 in primeList:
for prime2 in primeList:
if prime2 < prime1:
continue
number = prime1 * prime2
if number > upperLimit:
continue
phi = (prime1 - 1) * (prime2 - 1)
# print number, phi
if hashSort(number) == hashSort(phi):
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from EratosthenesSieve import *
sieve=EratosthenesSieve()
sieve.growToNumber(2000000)
print sum(sieve.sieve())
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from EratosthenesSieve import *
import copy
upperLimit = (10 ** 4) + 100
eratosthenesSieve = EratosthenesSieve()
eratosthenesSieve.growToNumber(upperLimit)
primeList = copy.copy(eratosthenesSieve.sieve())
primeSet = set(primeList)
# print primeList
remarkableListList = []
def isRemarkable(first, second):
firstSecond = int(str(first) + str(second))
secondFirst = int(str(second) + str(first))
sieve = eratosthenesSieve
return sieve.isPrime(firstSecond) and sieve.isPrime(secondFirst)
remarkableList = []
primeCount = len(primeList)
for i in range(0, primeCount):
for j in range(i, primeCount):
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from EratosthenesSieve import *
sieve=EratosthenesSieve()
sieve.growToNumber(120000)
print sieve.sieve()[10000]
primesUpperLimit = 100000
coefficientRange = range(-999, 1000)
class Polynom:
def __init__(self, coefficients):
self.__coefficients = coefficients
def evaluate(self, number):
result = 0
for (counter, coefficient) in enumerate(reversed(self.__coefficients)):
result += coefficient * number ** counter
return result
sieve = EratosthenesSieve()
sieve.growToNumber(primesUpperLimit)
primeSet = set(sieve.sieve())
maxPrimesCount = 0
maxA = 0
maxB = 0
for a in coefficientRange:
for b in coefficientRange:
polynom = Polynom([1, a, b])
primesCount = 0
for i in range(0, 81):
if polynom.evaluate(i) in primeSet:
primesCount += 1
else:
if primesCount > maxPrimesCount:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from EratosthenesSieve import *
import bisect
import math
upperLimit=100000
sieve=EratosthenesSieve()
sieve.growToNumber(upperLimit)
primeList=sieve.sieve()
primesSet=set(primeList)
def isSquare(number):
#print number
assumedSqrt=int(math.sqrt(number))
return assumedSqrt**2==number
for i in range(3, upperLimit, 2):
if not i in primesSet:
#print ">", i
maxPrimePos=bisect.bisect_left(primeList, i)+2
squareFound=False
for primePos in range(1, maxPrimePos):
squareAssumed=(i-primeList[primePos])/2
if squareAssumed<=0:
continue
if isSquare(squareAssumed):
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from EratosthenesSieve import *
sieve=EratosthenesSieve()
probablyEnough=10**5
sieve.growToNumber(probablyEnough)
primeList=sieve.sieve()
cache={}
def differentWaysWithMaximum(number, maximumIndex):
#print number, maximumIndex
numberSlashMaximum=str(number)+"/"+str(maximumIndex)
if (numberSlashMaximum in cache):
return cache[numberSlashMaximum]
#result=(0, [])
result=0
if 0==number:
result=(1, [[]])
result=1
else:
for i in reversed(range(0, maximumIndex+1)):
left=number-primeList[i]
if (left>=0):
#numberAndWays=differentWaysWithMaximum(left, i)
#array=result[1]+[([primeList[i]]+x) for x in numberAndWays[1]]
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from EratosthenesSieve import *
import math
upperPrimeLimit=1000000
eratosthenesSieve=EratosthenesSieve()
eratosthenesSieve.growToNumber(upperPrimeLimit)
primeList=eratosthenesSieve.sieve()
primeSet=set(primeList)
def getDiagonalNumbers(radius):
basenumber=2*radius+1
numberList=[]
for i in range(0, 4):
numberList.append(basenumber**2-i*(basenumber-1))
return tuple(set(numberList))
#print getDiagonalNumbers(2)
radius=1
primeNumbers=3
totalNumbers=5
while (totalNumbers/primeNumbers<10):
#print radius, primeNumbers, totalNumbers
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from EratosthenesSieve import *
sieve=EratosthenesSieve()
sieve.growToNumber(100)
primeList=list(sieve.sieve())
upperLimit=10**6
chosenPrimes=[]
primeProduct=1
for prime in primeList:
primeProduct*=prime
if primeProduct>upperLimit:
break
else:
chosenPrimes.append(prime)
print reduce(lambda a, b: a*b, chosenPrimes, 1)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from EratosthenesSieve import *
import pprint
knownProgression=[1487, 4817, 8147]
fourDigitsPrimes=[]
sieve=EratosthenesSieve()
sieve.growToNumber(10000)
for prime in sieve.sieve():
if prime>1000:
fourDigitsPrimes.append(prime)
#print fourDigitsPrimes
uniqueSortedDigits2PrimeList={}
for prime in fourDigitsPrimes:
uniqueSortedDigits="".join(sorted(list(set(list(str(prime))))))
if not uniqueSortedDigits in uniqueSortedDigits2PrimeList:
uniqueSortedDigits2PrimeList[uniqueSortedDigits]=[]
uniqueSortedDigits2PrimeList[uniqueSortedDigits].append(prime)
#print uniqueSortedDigits2PrimeList
def findProgressionInDelta(delta, pairs):
result=[]
while len(pairs)>=2:
currentProgressionIndex=[0]
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from Permutation import *
from EratosthenesSieve import *
import math
sieve=EratosthenesSieve()
sieve.growToNumber(7654321)
primeSet=set(sieve.sieve())
upperLimit=7
digits=range(1, upperLimit+1)
productSet=set()
pandigitalPrimes=[]
for i in range(0, math.factorial(upperLimit)):
permutation=nth_permutation(digits, i)
number=reduce(lambda a, b: 10*a+b, permutation)
if number in primeSet:
pandigitalPrimes.append(number)
print max(pandigitalPrimes)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.path.append("../lib")
from EratosthenesSieve import *
upperBound=10**6
sieve=EratosthenesSieve()
sieve.growToNumber(upperBound)
sieveList=sieve.sieve()
sieveSet=set(sieveList)
def isTruncatable(number, sieve):
digits=map(lambda e: int(e), str(number))
length=len(digits)
for i in range(1, length):
numberRight=reduce(lambda a, b: 10*a+b, digits[i:])
#print numberRight
numberLeft=reduce(lambda a, b: 10*a+b, digits[:-i])
#print numberLeft
if not numberRight in sieve or not numberLeft in sieve:
return False
return True
#print isTruncatable(3797, sieveSet)
truncatables=[]
for number in sieveList:
if (isTruncatable(number, sieveSet)):
