Python Helper.isPrime方法代码示例

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import isPrime [as 别名]
 def run(self):
     CONS = 4
     primes = [2, 3, 5, 7, 11, 13, 17, 19]
     n = 19
     consecutive = 0
     # Counting up
     while True:
         n = n + 1
         
         if Helper.isPrime(n):
             primes.append(n)
             consecutive = 0
             continue
         
         # loop through primes
         count = 0
         #ps = []
         for p in primes:
             if n % p == 0:
                 count = count + 1
                 #ps.append(p)
             if count == CONS:
                 #print('at n=' + str(n) + ' with consecutive: ' + str(consecutive))
                 consecutive = consecutive + 1
                 #print(ps)
                 break
         
         if count != CONS: # We didn't find distinct prime factors...
             consecutive = 0
         
         if consecutive == CONS:
             print(n)
             return

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import isPrime [as 别名]
 def biggestNStillPrime(self, a, b):
     n = 0
     while True:
         quad = self.calcQuadratic(n, (a, b))
         if (Helper.isPrime(quad)):
             n = n + 1
         else:
             return n - 1

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import isPrime [as 别名]
 def run(self):
     n = 9
     max = 0
     while True:
         n = n - 1
         for perm in Helper.listPermutations(n):
             if Helper.isPrime(int(perm)):
                 if int(perm) > max:
                     max = int(perm)
         if max > 0:
             print(max)
             break

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import isPrime [as 别名]
 def run(self):
     primes = [2, 3, 5, 7, 11, 13, 17, 19]
     twosquares = [2, 8, 18]
     nextsquare = 4
     # Loop over all numbers N
     n = 8
     while True:
         n = n + 1
         if n % 1000 == 0:
             print(n)
         # If prime, add to list of primes
         if Helper.isPrime(n):
             primes.append(n)
             continue
         # Check that we've cached enough 2x squares
         while twosquares[-1] < n:
             twosquares.append(2 * (nextsquare * nextsquare))
             nextsquare = nextsquare + 1
         
         found = False
         
         if n % 2 == 0:
             found = True
         # Loop over all primes P less than N
         for p in primes:
             if found:
                 break
             # Loop over all cached 2x squares K less than N
             for doublesquare in twosquares:
                 if found:
                     break
                 # If P + K = N: continue
                 if p + doublesquare == n:
                     found = True
                     
                 if p + doublesquare > n:
                     break
         
         # If we get to the end, print N and exit
         if not found:            
             print('OOPS!')
             print(str(n) + " couldn't be written as the sum of a prime and double a square")
             return

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import isPrime [as 别名]
    def run(self):
        print(self.isPermutation(1487, 4817))
        print(self.isPermutation(1487, 8147))
        # cache all 4-digit primes
        primes = []
        print('Caching primes...')
        for i in range(1000, 10000):
            if Helper.isPrime(i):
                primes.append(i)
        quickPrime = set(primes)
        
        print('Looking for suitable primes...')
        # loop over 4-digit primes P
        for i in range(0, len(primes)):
            p1 = primes[i]
            # loop over 4-digit primes P2 > P such that P + P2 < 10000
            for p2 in primes[i + 1:]:
                if p2 + p1 > 10000:
                    break
                
                if not self.isPermutation(p1, p2):
                    continue
                
                
                p3 = p2 + (p2 - p1)
                
                if p1 == 1487 and p2 == 4817:
                    print(self.isPermutation(p1, p3))

                if p3 > 10000:
                    break
                
                # Check if P2 - P is prime
                if p3 in quickPrime and self.isPermutation(p1, p3):
                    print('Yay!')
                    print(p1)
                    print(p2)
                    print(p3)
                    print(str(p1) + str(p2) + str(p3))

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import isPrime [as 别名]
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()

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import isPrime [as 别名]
# Largest prime factor
# Problem 3
#
# The prime factors of 13195 are 5, 7, 13 and 29.
# What is the largest prime factor of the number 600851475143 ?
import Helper

i = 1
while i < 600851475142:
    if 600851475143 % i == 0:
        if Helper.isPrime(i):
            print i
    i += 1

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import isPrime [as 别名]
 def isPrime(self, n):
     if n < self.maxPrime:
         return n in self.primes
     if not n in self.bigPrimes:
         self.bigPrimes[n] = Helper.isPrime(n)
     return self.bigPrimes[n]    

# 需要导入模块: import Helper [as 别名]
# 或者: from Helper import isPrime [as 别名]
 def calcRatio(self, diagonals):
     for candidate in diagonals:
         if Helper.isPrime(candidate):
             self.primes = self.primes + 1
     self.totalDiags = self.totalDiags + 4