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])
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