def run(self):
print('Caching primes...')
# NOTE: This is slow right now... To speed this up, I guess I should check if it's cyclical
# while calculating the primes
primes = Helper.primesLessThan(1000000)
print('Finding cyclical primes...')
count = 0
iterations = 0
for prime in primes:
if prime == 1:
continue
iterations = iterations + 1
if iterations % 10000 == 0:
print("I'm up to: " + str(prime))
if primes[prime]:
next_prime = self.cycle(prime)
is_circular = True
counter = 0
while int(next_prime) != prime:
counter = counter + 1
if counter > 1000:
print('I seem to be stuck:')
print(prime)
print(next_prime)
if not primes[int(next_prime)]:
is_circular = False
next_prime = self.cycle(next_prime)
if is_circular:
count = count + 1
print(count)
def run(self):
MAX = 1000000
primesDict = Helper.primesLessThan(MAX)
primes = [p for p in primesDict.keys() if primesDict[p]]
maxSequence = 2
print(len(primes))
for i in range(0, len(primes)):
if len(primes) - i < maxSequence:
break
sum = primes[i]
j = i
while True:
j = j + 1
sum = sum + primes[j]
if sum >= MAX:
break
seqLength = j - i + 1
if primesDict[sum] and seqLength > maxSequence:
print(
"Found new max sequence: p="
+ str(sum)
+ " seqLength="
+ str(seqLength)
+ " seqStart="
+ str(primes[i])
)
maxSequence = seqLength
def run(self):
max = 1000000
self.primes = Helper.primesLessThan(max)
count = 0
for i in range (11, max):
if self.isPrimeReducable(i):
print(i)
count = count + 1
print(count)
def findAnswer(self):
candidates = Helper.primesLessThan(10000)
bCandidates = [k for k in candidates if candidates[k] == True and k <= 1000]
bCandidates.reverse()
aCandidates = range(-999, 1000)
print('Searching with a values: ' + str(aCandidates[0]) + ' <-> ' + str(aCandidates[-1]))
maxPair = (0, 0)
maxN = 0
for b in bCandidates:
print('Testing b candidate: ' + str(b))
for a in aCandidates:
n = self.biggestNStillPrime(a, b)
if n > maxN:
print('New biggest n: ' + str(n) + ' for pair: ' + str(a) + ',' + str(b))
maxN = n
maxPair = (a, b)
print(self.calcQuadratic(maxN, maxPair))
def run(self):
MAX = 1000000
print(self.findPerms(5603))
print('Caching primes...')
primesDict = Helper.primesLessThan(MAX);
maxFamily = 6
primes = [p for p in primesDict.keys() if primesDict[p] and p > 56003]
print('Starting search of ' + str(len(primes)) + ' primes...')
count = 0
for prime in primes:
if len(str(prime)) < 3:
continue
count = count + 1
if count % 1000 == 0:
print('Processing Prime number: ' + str(count))
family = self.findPrimeFamily(prime, primesDict)
if family > maxFamily:
print(family)
print(prime)
maxFamily = family
def print_primes():
increment = 35000000
iterations = 5
iteration = 1
allNumbers = Helper.primesLessThan(increment)
primes = [num for num in allNumbers if allNumbers[num]]
# Because of memory constraints, I can't apply the seive all at once, instead I apply it incrementally
while iteration < iterations:
# First reset the map to free up the memory
allNumbers = defaultdict(trueFactory)
# Now we have to eliminate multiples of all primes found so far from the current range (as if the seive had been applied all along)
iteration = iteration + 1
start = (iteration - 1) * increment
maximum = increment * iteration
allNumbers[start] = Helper.isPrime(start)
for prime in primes:
i = int(start / prime) + 1
while i * prime < maximum:
allNumbers[i * prime] = False
i = i + 1
# Finally we are ready to continue with the seive as per normal
for number in range(start, int(maximum / 2) + 1):
if allNumbers[number]:
i = 2
while i * number < maximum:
allNumbers[i * number] = False
# Add these new primes to the ones we already now about, rinse and repeat
primes = primes + [num for num in range(start, maximum) if allNumbers[num]]
f = open("./primes", "w")
for prime in primes:
f.write(str(prime) + "\n")
f.close()
