Example #1
0
class Problem58:
    
    def __init__(self):
        self.primeChecker = PrimeChecker()
        self.primeChecker.initPrimeFactoring()

    def getDiagonalsFromSpiralOfSize(self, size, diagonals=None):
        counter = 1
        if diagonals == None:
            diagonals = []
            for i in range(0, int((size-1)/2)):
                for _ in range(0, 4):
                    counter += 2 + 2*i
                    diagonals.append(counter)
        else:
            i = int((size-1)/2) - 1
            counter = int(diagonals[-1])
            for _ in range(0, 4):
                counter += 2 + 2*i
                diagonals.append(counter)
        return diagonals
    
    def answer(self):
        size = 1
        ratio = 100
        diagonals = None
        totalPrimes = 0
        while ratio >= 0.10:
            size += 2
            diagonals = self.getDiagonalsFromSpiralOfSize(size, diagonals)
            total = (size-1)/2 * 4 + 1
            totalPrimes += len([x for x in diagonals[-4:-1] if self.primeChecker.isPrime(x)])
            ratio = totalPrimes / total
        return size
            
Example #2
0
 def get_longest_sum_of_consecutive_primes_below(n):
     longest_sequence_length = 0
     longest_sum = 0
     primes = PrimeChecker.primes_below(n)
     for i in range(0, len(primes)):
         for j in range(i + 1, len(primes) - 1):
             prime_sum = sum(primes[i:j])
             if prime_sum >= n:
                 break
             if PrimeChecker.is_prime(prime_sum) and j - i > longest_sequence_length:
                 longest_sequence_length = j - i
                 longest_sum = prime_sum
     return longest_sequence_length, longest_sum
Example #3
0
 def getLongestSumOfConsecutivePrimesBelow(self, n):
     longestSequenceLength = 0
     longestSum = 0
     primes = PrimeChecker.primesBelow(n)
     for i in range(0, len(primes)):
         for j in range(i+1, len(primes)-1):
             primeSum = sum(primes[i:j])
             if primeSum >= n:
                 break
             if PrimeChecker.isPrime(primeSum) and j - i > longestSequenceLength:
                 longestSequenceLength = j - i
                 longestSum = primeSum
     return longestSequenceLength, longestSum
Example #4
0
 def triSequenceIsPrimeAndPermutation(self, start, step):
     for n in range(0, 3):
         if not PrimeChecker.isPrime(start+n*step):
             return False
     for n in range(0, 2):
         if not self.isPermutationOf(n, start):
             return False
     return True
Example #5
0
 def hasPrimeVariations(self, number, replaceDigit, primeVariations):
     primeCount = 0
     for i in range(0, 10):
         testNumber = number.replace(replaceDigit, str(i))
         if PrimeChecker.isPrime(int(testNumber)) \
         and self.hasEqualNumberOfDigits(testNumber, number):
             primeCount += 1
     return primeCount == primeVariations
Example #6
0
 def tri_sequence_is_prime_and_permutation(self, start, step):
     for n in range(0, 3):
         if not PrimeChecker.is_prime(start + n * step):
             return False
     for n in range(0, 3):
         if not self.is_permutation_of(start + n * step, start):
             return False
     return True
Example #7
0
 def answer(self):
     for prime in PrimeChecker.primesBelow(1000000):
         if prime > 100000:
             s = str(prime)
             lastDigit = s[5:6]
             if s.count("0") == 3 and self.hasPrimeVariations(s, "0", 8) \
             or s.count("1") == 3 and lastDigit != 1 and self.hasPrimeVariations(s, "1", 8) \
             or s.count("2") == 3 and self.hasPrimeVariations(s, "2", 8):
                 return int(s) 
Example #8
0
class Problem47:
    def __init__(self):
        self.primeChecker = PrimeChecker()
        self.primeChecker.init_prime_factoring()

    def find_consecutive_prime(self, n):
        i = 1
        while True:
            for j in range(0, n):
                if not len(self.primeChecker.get_unique_prime_factors(i, True)) == n:
                    break
                i += 1
                if j == n - 1:
                    return i - n
            i += 1

    def answer(self):
        return self.find_consecutive_prime(4)
Example #9
0
class Problem60:
    def __init__(self, prime_limit):
        self.primeChecker = PrimeChecker()
        self.primeChecker.init_prime_factoring()
        self.primes = PrimeChecker.primes_below(prime_limit)
        self.primes.remove(2)
        self.pairs = self.build_pairs(self.primes)
    
    def build_pairs(self, primes):
        pairs = dict()
        for p1 in primes:
            if p1 == 5:
                continue
            pairs[p1] = set()
            for q in range(primes.index(p1), len(primes)):
                p2 = primes[q]
                if self.primeChecker.is_prime(int(str(p1) + str(p2))) and \
                        self.primeChecker.is_prime(int(str(p2) + str(p1))):
                    pairs[p1].add(p2)
        return pairs
    
    def answer(self):
        lowest = 10000000
        for p1 in self.pairs:
            for p2 in self.pairs[p1]:
                set_a = self.pairs[p1] & self.pairs[p2]
                if len(set_a) > 0:
                    for p3 in set_a:
                        set_b = set_a & self.pairs[p3]
                        if len(set_b) > 0:
                            for p4 in set_b:
                                set_c = set_b & self.pairs[p4]
                                if len(set_c) > 0:
                                    total = sum([p1, p2, p3, p4] + list(set_c))
                                    if total < lowest:
                                        lowest = total
        return lowest
Example #10
0
class TestProblem47(unittest.TestCase):

    def setUp(self):
        self.primeChecker = PrimeChecker()
        self.primeChecker.initPrimeFactoring()
        pass
    
    def tearDown(self):
        pass

    def test_47ShouldBeAPrime(self):
        self.assertTrue(PrimeChecker.isPrime(47))

    def test_27ShouldNotBeAPrime(self):
        self.assertFalse(PrimeChecker.isPrime(27))
        
    def test_primesBelow20ShouldBe235711131719(self):
        self.assertEquals([2,3,5,7,11,13,17,19], PrimeChecker.primesBelow(20))
        
    def test_primeFactorsFor644ShouldBe22723(self):
        self.assertEquals([2,2,7,23], self.primeChecker.getPrimeFactors(644, True))
        
    def test_uniquePrimeFactorsFor644ShouldBe2723(self):
        self.assertEquals([2,7,23], self.primeChecker.getUniquePrimeFactors(644, True))
Example #11
0
 def setUp(self):
     self.primeChecker = PrimeChecker()
     self.primeChecker.initPrimeFactoring()
     pass
Example #12
0
 def test_primesBelow20ShouldBe235711131719(self):
     self.assertEquals([2,3,5,7,11,13,17,19], PrimeChecker.primesBelow(20))
Example #13
0
 def test_27ShouldNotBeAPrime(self):
     self.assertFalse(PrimeChecker.isPrime(27))
Example #14
0
 def test_47ShouldBeAPrime(self):
     self.assertTrue(PrimeChecker.isPrime(47))
Example #15
0
 def __init__(self, prime_limit):
     self.primeChecker = PrimeChecker()
     self.primeChecker.init_prime_factoring()
     self.primes = PrimeChecker.primes_below(prime_limit)
     self.primes.remove(2)
     self.pairs = self.build_pairs(self.primes)
Example #16
0
 def __init__(self):
     self.primeChecker = PrimeChecker()
     self.primeChecker.initPrimeFactoring()
Example #17
0
 def __init__(self, primeLimit):
     self.primeChecker = PrimeChecker()
     self.primeChecker.initPrimeFactoring()
     self.primes = PrimeChecker.primesBelow(primeLimit)
     self.primes.remove(2)
     self.pairs = self.buildPairs(self.primes)