コード例 #1
0
def spiral_primes():

    lCount = 0
    lSide = 3

    while (True):

        lInt = lSide ** 2
        lSideM1 = lSide - 1

        if utils.is_prime(lInt - lSideM1):
            lCount += 1

        if utils.is_prime(lInt - lSideM1 * 2):
            lCount += 1

        if utils.is_prime(lInt - lSideM1 * 3):
            lCount += 1

        lRatio = lCount / (lSide * 2 - 1)

#         print('Side: ' + str(i) + ' Primes: ' + str(lCount) + ' Total: '
#                        + str(i * 2 - 1) + ' Ratio: '
#                        + str(lRatio))

        if lRatio < 0.1:
            return lSide

        lSide += 2
コード例 #2
0
def quadratic_primes(pInt):

    lSieve = sieve_eratosthenes(pInt, pInt)

    lPrimes = []

    for i in range(1, pInt):
        if lSieve[i] == 1:
            lPrimes.append(i)

    lMaxNumPrime = 0
    lMaxA = 0
    lMaxB = 0

    for b in lPrimes:
        for a in range(-pInt, pInt + 1):

            lCurrNumPrime = 0
            lN = 0

            while is_prime(lN * lN + a * lN + b):
                lCurrNumPrime += 1
                lN += 1

            if lCurrNumPrime > lMaxNumPrime:
                lMaxNumPrime = lCurrNumPrime
                lMaxA = a
                lMaxB = b

    return(lMaxA, lMaxB, lMaxNumPrime)
コード例 #3
0
def pandigital_prime():

    for i in list(itertools.permutations([7, 6, 5, 4, 3, 2, 1], 7)):
        lStr = ''

        for j in i:
            lStr += str(j)

        lInt = int(lStr)

        if is_prime(lInt):
            return lInt

    return None
コード例 #4
0
def main():
    """
    By listing the first six prime numbers: 2, 3, 5, 7, 11, and 13, we can see that the 6th prime is 13.
    What is the 10 001st prime number?
    """
    limit = 10001
    n = 2
    i = 0
    while True:
        if is_prime(n):
            i += 1
        if i == limit:
            break
        if n == 2:
            n += 1
        else:
            n += 2
    return n
コード例 #5
0
ファイル: p046.py プロジェクト: ololo123321/euler
def main():
    """
    https://projecteuler.net/problem=46
    """
    primes = [2]
    n = 1
    while True:
        n += 2
        if is_prime(n):
            primes.append(n)
            continue
        is_bad = True
        for p in primes:
            q = ((n - p) / 2)**0.5
            if q.is_integer():
                is_bad = False
                break
        if is_bad:
            return n
コード例 #6
0
def prime_pair_sets():

    lMaxT = 10 ** 6
    lSieve = sieve_eratosthenes(lMaxT, lMaxT)

    lPrimes = []

    lMaxP = 10 ** 4

    for i in range(1, lMaxT):
        if lSieve[i] == 1:
            lPrimes.append(i)
            if i < lMaxP:
                lMaxPrime = i

    lMaxI = lPrimes.index(lMaxPrime) + 1

    lInts = np.empty(5, dtype='S10')

    for i1 in range(0, lMaxI - 4):
        lPrime1 = lPrimes[i1]
        lInts[0] = str(lPrime1)

        if lPrime1 == 2:
            continue

        if lPrime1 == 5:
            continue

#         print('i1: ' + str(lPrime1))

        for i2 in range(i1 + 1, lMaxI - 3):
            lPrime2 = lPrimes[i2]
            lInts[1] = str(lPrime2)

            if lPrime2 == 5:
                continue

            lInt = int(lInts[0] + lInts[1])

            if lInt > lMaxT:
                if not is_prime(lInt):
                    continue
            elif lSieve[lInt] == 0:
                continue

            lInt = int(lInts[1] + lInts[0])

            if lInt > lMaxT:
                if not is_prime(lInt):
                    continue
            elif lSieve[lInt] == 0:
                continue

#             print('i1: ' + str(lPrime1) + ' i2: ' + str(lPrime2))

            for i3 in range(i2 + 1, lMaxI - 2):
                lPrime3 = lPrimes[i3]
                lInts[2] = str(lPrime3)

                if lPrime3 == 5:
                    continue

                lInt = int(lInts[0] + lInts[2])

                if lInt > lMaxT:
                    if not is_prime(lInt):
                        continue
                elif lSieve[lInt] == 0:
                    continue

                lInt = int(lInts[2] + lInts[0])

                if lInt > lMaxT:
                    if not is_prime(lInt):
                        continue
                elif lSieve[lInt] == 0:
                    continue

                lInt = int(lInts[1] + lInts[2])

                if lInt > lMaxT:
                    if not is_prime(lInt):
                        continue
                elif lSieve[lInt] == 0:
                    continue

                lInt = int(lInts[2] + lInts[1])

                if lInt > lMaxT:
                    if not is_prime(lInt):
                        continue
                elif lSieve[lInt] == 0:
                    continue

#                 print('i1: ' + str(lPrime1) + ' i2: ' + str(lPrime2)
#                                             + ' i3: ' + str(lPrime3))

                for i4 in range(i3 + 1, lMaxI - 1):
                    lPrime4 = lPrimes[i4]
                    lInts[3] = str(lPrime4)

                    lInt = int(lInts[0] + lInts[3])

                    if lInt > lMaxT:
                        if not is_prime(lInt):
                            continue
                    elif lSieve[lInt] == 0:
                        continue

                    lInt = int(lInts[3] + lInts[0])

                    if lInt > lMaxT:
                        if not is_prime(lInt):
                            continue
                    elif lSieve[lInt] == 0:
                        continue

                    lInt = int(lInts[1] + lInts[3])

                    if lInt > lMaxT:
                        if not is_prime(lInt):
                            continue
                    elif lSieve[lInt] == 0:
                        continue

                    lInt = int(lInts[3] + lInts[1])

                    if lInt > lMaxT:
                        if not is_prime(lInt):
                            continue
                    elif lSieve[lInt] == 0:
                        continue

                    lInt = int(lInts[2] + lInts[3])

                    if lInt > lMaxT:
                        if not is_prime(lInt):
                            continue
                    elif lSieve[lInt] == 0:
                        continue

                    lInt = int(lInts[3] + lInts[2])

                    if lInt > lMaxT:
                        if not is_prime(lInt):
                            continue
                    elif lSieve[lInt] == 0:
                        continue

#                     print('i1: ' + str(lPrime1) + ' i2: ' + str(lPrime2)
#                                                 + ' i3: ' + str(lPrime3)
#                                                 + ' i4: ' + str(lPrime4))

                    for i5 in range(i4 + 1, lMaxI):
                        lPrime5 = lPrimes[i5]
                        lInts[4] = str(lPrime5)

                        lInt = int(lInts[0] + lInts[4])

                        if lInt > lMaxT:
                            if not is_prime(lInt):
                                continue
                        elif lSieve[lInt] == 0:
                            continue

                        lInt = int(lInts[4] + lInts[0])

                        if lInt > lMaxT:
                            if not is_prime(lInt):
                                continue
                        elif lSieve[lInt] == 0:
                            continue

                        lInt = int(lInts[1] + lInts[4])

                        if lInt > lMaxT:
                            if not is_prime(lInt):
                                continue
                        elif lSieve[lInt] == 0:
                            continue

                        lInt = int(lInts[4] + lInts[1])

                        if lInt > lMaxT:
                            if not is_prime(lInt):
                                continue
                        elif lSieve[lInt] == 0:
                            continue

                        lInt = int(lInts[2] + lInts[4])

                        if lInt > lMaxT:
                            if not is_prime(lInt):
                                continue
                        elif lSieve[lInt] == 0:
                            continue

                        lInt = int(lInts[4] + lInts[2])

                        if lInt > lMaxT:
                            if not is_prime(lInt):
                                continue
                        elif lSieve[lInt] == 0:
                            continue

                        lInt = int(lInts[3] + lInts[4])

                        if lInt > lMaxT:
                            if not is_prime(lInt):
                                continue
                        elif lSieve[lInt] == 0:
                            continue

                        lInt = int(lInts[4] + lInts[3])

                        if lInt > lMaxT:
                            if not is_prime(lInt):
                                continue
                        elif lSieve[lInt] == 0:
                            continue

#                         print('i1: ' + str(lPrime1) + ' i2: ' + str(lPrime2)
#                                                     + ' i3: ' + str(lPrime3)
#                                                     + ' i4: ' + str(lPrime4)
#                                                     + ' i5: ' + str(lPrime5))

                        return (lPrime1 + lPrime2 + lPrime3
                                        + lPrime4 + lPrime5)
    return None