コード例 #1
0
def first_triangular_with_k_divisors(k, lo=2, hi=10**3, pt=None):
    '''
    ---------------------------------------------------------------------------
    first_triangular_with_k_divisors
    ---------------------------------------------------------------------------
    Returns the first triangular number that has k divisors.

    Searches in the range [lo, hi) initially, if it fails to find a result,
    then it doubles the search range by 2 (i.e. lo <- hi, hi <- 2*hi) and
    searches there. You can optionally provide lo and hi to start the search,
    otherwise, these default to 2 and 10**3.

    Uses a PrimeTools object to compute divisors, which can optionally be
    provided. If not provided, will use PrimeTools(hi * (hi+1) / 2).
    '''
    if pt is None:
        pt = PrimeTools(triangle(hi))
    else:
        pt.extend(triangle(hi))

    for i in range(lo, hi):
        tri = triangle(i)
        n_divisors = pt.n_divisors(tri)
        if n_divisors > k:
            return tri

    else:
        return first_triangular_with_k_divisors(k, lo=hi, hi=2 * hi, pt=pt)
コード例 #2
0
def solve_prob(n=600851475143, pt=None):
    if pt is None:
        pt = PrimeTools(10**5)

    factorization = pt.factorize(n)
    prime_factors = [p for (p, e) in factorization]

    return max(prime_factors)
コード例 #3
0
def find_nth_prime(n, pt=None):
    if pt is None:
        # if no primetools object has been provided, then
        # begin by finding all primes below 100
        m = 100
        pt = PrimeTools(m)

    # keep extending prime list until we have n primes
    while len(pt.prime_list) < n:
        m = 2 * m
        pt.extend(m)

    return pt.prime_list[n - 1]
コード例 #4
0
ファイル: prob_0010.py プロジェクト: pkepley/proj-e
def sum_primes_below(n, pt=None):
    '''
    ---------------------------------------------------------------------------
    sum_primes_below
    ---------------------------------------------------------------------------
    Sum primes below n, excluding n itself. I.e. it returns:
        sum([p : p prime, p < n])
    You can optionally provide a pre-computed PrimeTools object (pt) whose
    sieve will be extended if necessary.
    '''
    if pt is None:
        pt = PrimeTools(n)
    else:
        pt.extend(n)

    return sum([p for p in pt.prime_list if p < n])
コード例 #5
0
ファイル: Problem3.py プロジェクト: ttata/Project-Euler
def biggestPrimeFactor(findPrime):
    primes = PrimeTools.findAllPrimes(math.sqrt(findPrime))
    maxPrime = 1
    for prime in primes:
        if findPrime % prime == 0 and prime != findPrime:
            maxPrime = prime
    return maxPrime
コード例 #6
0
ファイル: Problem7.py プロジェクト: ttata/Project-Euler
def findPrimeSequence(target):
    primes = [2, 3, 5, 7, 11, 13]
    primesSeen = 6
    start = 15
    while primesSeen < target:
        if(PrimeTools.isNumberPrime(start, primes)):
            primesSeen += 1
            primes.append(start)
        start += 2
    return start - 2
コード例 #7
0
ファイル: Problem10.py プロジェクト: ttata/Project-Euler
def addAllPrimes(number):
    return sum(PrimeTools.findAllPrimes(number))
コード例 #8
0
ファイル: prob_0111.py プロジェクト: pkepley/proj-e
'''
   Problem 111: https://projecteuler.net/problem=111

   Solved: 2019-03-17
'''


import itertools
from PrimeTools import PrimeTools


# start out with a sieve up to 10**5
_pt_ = PrimeTools(10**5)


def kbits(n, k):
    '''
    ---------------------------------------------------------------------
    kbits(n,k)
    ---------------------------------------------------------------------
    Generate list of all n-bit bit-patterns with exactly k bits set to 1.
    '''
    # https://stackoverflow.com/q/1851134/3677367
    result = []
    for bits in itertools.combinations(range(n), k):
        s = [0] * n
        for bit in bits:
            s[bit] = 1
        result.append(s)
    return result