#!/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 * 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 * 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)
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: maxPrimesCount = primesCount maxA = a
#!/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 * sieve=EratosthenesSieve() sieve.growToNumber(120000) print sieve.sieve()[10000]
#!/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 * 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 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)):