def testPrimesLowerThan2000(self):
soa = SieveOfAtkin(2000)
primesLowerThan2000 = [x for x in self.primes if x < 2000]
primes = soa.getPrimes()
primes.sort()
primesLowerThan2000.sort()
self.assertEqual(primes, primesLowerThan2000)
def testPrimesLowerThan100(self): soa = SieveOfAtkin(100) primesLowerThan100 = [x for x in self.primes if x<100] primes = soa.getPrimes() primes.sort() primesLowerThan100.sort() self.assertEqual(primes, primesLowerThan100)
def testInvalidate(self): soa = SieveOfAtkin(10) soa.invalidate(2) self.assertFalse(soa.sieve[2]) soa.flip(2) self.assertTrue(soa.sieve[2])
def testFlip(self): soa = SieveOfAtkin(10) soa.flip(2) self.assertTrue(soa.sieve[2]) soa.flip(2) self.assertFalse(soa.sieve[2])
def testInvalidate(self):
soa = SieveOfAtkin(10)
soa.invalidate(2)
self.assertFalse(soa.sieve[2])
soa.flip(2)
self.assertTrue(soa.sieve[2])
def testFlip(self):
soa = SieveOfAtkin(10)
soa.flip(2)
self.assertTrue(soa.sieve[2])
soa.flip(2)
self.assertFalse(soa.sieve[2])
from sieve_of_atkin import SieveOfAtkin
soa = SieveOfAtkin(1000000)
primes = set(soa.getPrimes())
s = 0
def rotate(n):
return int(str(n)[-1] + str(n)[:-1])
def isCircularPrime(n):
v = rotate(n)
while n != v:
if v not in primes:
return False
v = rotate(v)
return True
for i in primes:
if isCircularPrime(i):
s += 1
print s
# The intended value has to be in the primes list, meaning < limit.
# The biggest possible sequence will involve the smallest primes that add up
# to limit.
def get_max_sequence():
seq = 0
s = 0
while (s < limit):
s += primes_list[seq]
seq += 1
return seq
limit = 1000000
# Generate list of primes.
soa = SieveOfAtkin(limit)
primes = set(soa.getPrimes())
# Because result is given as a set, turn into a list and sort it.
primes_list = list(primes)
primes_list.sort()
# We know that the sequence will have a maximum:
# - only consider sequences of that size or smaller
for l in xrange(get_max_sequence(), 1, -1):
i = 0
value = sum(primes_list[i:i + l])
# Because the value has to be in primes_list, no need to check values bigger
# than the limit.
while value < limit:
if value in primes:
print l, value
exit(0)
def main():
primes_sieve = SieveOfAtkin(100000)
return primes_sieve.get_nth_prime(10001)
from sieve_of_atkin import SieveOfAtkin # The intended value has to be in the primes list, meaning < limit. # The biggest possible sequence will involve the smallest primes that add up # to limit. def get_max_sequence(): seq = 0 s = 0 while(s < limit): s += primes_list[seq] seq +=1 return seq limit = 1000000 # Generate list of primes. soa = SieveOfAtkin(limit) primes = set(soa.getPrimes()) # Because result is given as a set, turn into a list and sort it. primes_list = list(primes) primes_list.sort() # We know that the sequence will have a maximum: # - only consider sequences of that size or smaller for l in xrange(get_max_sequence(), 1, -1): i = 0 value = sum(primes_list[i:i+l]) # Because the value has to be in primes_list, no need to check values bigger # than the limit. while value < limit: if value in primes: print l, value exit(0)
def testIsPrime(self): soa = SieveOfAtkin(100) self.assertFalse(soa.isPrime(2)) soa.flip(2) self.assertTrue(soa.isPrime(2))
return nod * 2
exponent = 1
while remain % prime_list[i] == 0:
exponent += 1
remain /= prime_list[i]
nod *= exponent
# If there is no remainder, return the count
if remain == 1:
return nod
return nod
number = 0
i = 1
soa = SieveOfAtkin(75000)
prime_list = soa.getPrimes()
"""
while NumberOfDivisors(number) < 500:
number += i
i +=1
"""
while PrimeFactorisationNoD(number, prime_list) < 500:
number += i
i +=1
print number
""" - Fermat's little theorem: 1/d has a cicle of n digits if 10^n - 1 mod n = 0 - If d is prime, than it can have a up to d - 1 repeating decimal digits - So, find the last prime p, under 1000, that has p - 1 digits """ from sieve_of_atkin import SieveOfAtkin soa = SieveOfAtkin(1000) primes = soa.getPrimes() primes.sort() # just to be sure primes.reverse() for prime in primes: cycle = 1 while (pow(10, cycle) - 1 ) % prime != 0: cycle += 1 if prime - cycle == 1: break print prime
def testIsPrime(self):
soa = SieveOfAtkin(100)
self.assertFalse(soa.isPrime(2))
soa.flip(2)
self.assertTrue(soa.isPrime(2))
def main():
primes_sieve = SieveOfAtkin(100000)
return primes_sieve.get_nth_prime(10001)
