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

    limit = 10**6

    # find the smallest list of primes which will sum up to at least the limit we set above
    for x in count(1):
        primes = list(get_primes_under(10**x))
        if sum(primes) > limit:
            break

    # starting with the longest possible sequence (every element in the list), and then working
    # to smaller sequence lengths
    for length in reversed(range(1, len(primes) + 1)):

        # Use a "sliding window" approach. Starting at the low end of the list, grab the first
        # `length` elements and check it. Then slide the window right 1 element, and grab those,
        # and check it, etc
        for start in range(len(primes)-length):
            candidate = sum(primes[start:start+length])

            # if the candidate sum is bigger than the limit, no point in checking any more windows
            # of size `length`. Break the inner loop, and reduce the length
            if candidate >= limit:
                break

            # if the candidate sum is prime, we're done!
            if is_prime(candidate):
                print(candidate)
                return
コード例 #2
0
def problem_49():

    # get a generator of primes under 10k (since we know the primes in question are 4 digits)
    # and then discard all 3-digit ones
    primes = get_primes_under(10**4)
    while next(primes) < 999:
        pass

    # turn the remainder of the primes in the generator into a list
    primes = list(primes)

    for p in primes:
        if p in (1487, 4817, 8147):
            # skip this one since the problem is asking for the other one
            continue

        # get the digits of the current prime in sorted order, and get any other primes
        # in the list which contain exactly the same digits
        sorted_digits = sorted(str(p))
        others = [x for x in primes if x != p and sorted(str(x)) == sorted_digits]

        # if we don't have at least 2 other primes with the same digits, skip to the next prime
        if len(others) < 2:
            continue

        # check each pair of primes in the `others` list, and if the difference between them is
        # the same as the difference between our current prime and the first of these, we have
        # a winner
        for n1 in others:
            for n2 in [x for x in others if x > n1]:
                if (n2 - n1) == (n1 - p):
                    print('{}{}{}'.format(p, n1, n2))
                    return
コード例 #3
0
def can_be_written_as_prime_plus_twice_square(n):
    """ Returns True if n can be written as the sum of a prime and twice a square number, or
    returns False otherwise. """

    if is_prime(n):
        return True

    # For every prime under n, find what value of x satisfies:   n = prime + 2x^2
    # If any of those values x are an integer, then n can be written as prime + 2x square number
    for prime in get_primes_under(n):
        x = ((n - prime) / 2) ** 0.5
        if x % 1 == 0:
            return True

    # If we get here, n cannot be written as prime + 2x square number
    return False
コード例 #4
0
def problem_60():

    # get list of primes, discard 2
    primes = list(get_primes_under(9000))
    primes.pop(0)

    for a in primes:

        # build up a list of primes which pair with `a` to concatenate and form other primes
        pairs_with_a = list()
        for b in primes:
            if a == b: continue
            if concats_to_prime(a, b):
                pairs_with_a.append(b)

        # For every combination of 4 in the primes which pair with `a`:
        #     if every pair of them also concats_to_prime, we found the winner!
        # 
        # We know the first result obtained must be the correct answer, since combinations()
        # yield combos in lexographical order, so we'll get combos with smaller numbers first
        for combo in combinations(pairs_with_a, 4):
            if all(concats_to_prime(p1, p2) for p1, p2 in product(combo, repeat=2) if p1 != p2):
                print(sum(combo) + a)
                return
コード例 #5
0
def problem_10():
    print(sum(get_primes_under(2000000)))
コード例 #6
0
644 = 2² × 7 × 23
645 = 3 × 5 × 43
646 = 2 × 17 × 19.

Find the first four consecutive integers to have four distinct prime factors. What is the first
of these numbers?
"""

from utils.timer import time_it
from utils.primes import get_primes_under
from itertools import count

#-------------------------------------------------------------------------------------------------

# this limit determined experimentally
primes = list(get_primes_under(10**3))

def has_4_distinct_prime_factors(n):
    """ Returns True if n has exactly 4 distinct prime factors, or False otherwise. """

    factor_count = 0
    for p in primes:
        if n % p == 0:
            # if it already has 4 factors so far, another will disqualify it, so just return False
            if factor_count == 4:
                return False
            factor_count += 1

    # we don't have any more than 4 here, but make sure we don't have less
    return factor_count == 4