Ejemplo n.º 1
0
def challenge127():
    maximum = 120000

    primes = list(sievedPrimes(maximum))

    rads = [1,] * maximum

    for prime in primes[1:]:
        for i in xrange(prime - 1, maximum, prime):
            rads[i] *= prime

    rad_lookup = [[r, i + 1] for i, r in enumerate(rads)]

    rad_lookup.sort()

    result = 0
    for c in xrange(1, maximum + 1):
        for next in rad_lookup:
            a = next[1]
            if next[0] * rads[c - 1] >= c:
                break
            b = c - a

            if a < (c / 2) and next[0] * rads[b - 1] * rads[c - 1] < c and \
                    gcd(a, b) == 1:
                result += c

    return result
Ejemplo n.º 2
0
def challenge234():
    # Get primes needed
    limit = 999966663333
    primes = sievedPrimes(1000000)

    primes.next()
    current = primes.next()

    total = list()

    for next in primes:

        # square of current will definitely not be semidivisable
        lows = set(myrange(current**2 + current, 
                          next**2 if next**2 < limit + 1 else limit + 1,
                          current))

        highest = next**2 - next
        while highest > limit:
            highest -= next

        highs = set(myrange(highest, current**2, -next))

        # Get numbers in one or other but not both
        valid = lows.symmetric_difference(highs)

        total.extend(list(valid))

        current = next

    return sum(t for t in total if t < limit)
Ejemplo n.º 3
0
def challenge087():
    limit = 50000000
    # Get potential squares
    sqLimit = int(limit**0.5)
    primes = list(sievedPrimes(sqLimit))
    primes.remove(1)
    sqPrimes = list([n**2 for n in primes])

    # Get potential cubes
    cuLimit = int(limit**(1.0 / 3.0))
    cuPrimes = list([n**3 for n in [n for n in primes if n <= cuLimit]])

    # Get potential fourths
    foLimit = int(limit**(0.25))
    foPrimes = list([n**4 for n in [n for n in primes if n <= foLimit]])

    nAnswers = set()
    for s in sqPrimes:
        for c in cuPrimes:
            sc = s + c
            if sc >= limit:
                break
            for f in foPrimes:
                scf = sc + f
                if scf >= limit:
                    break
                nAnswers.add(scf)

    return len(nAnswers)
Ejemplo n.º 4
0
def challenge131():
    limit = 1000000
    primes = list(sievedPrimes(limit))

    # n**3 + n**2*p = m**3
    # n**2 * (n + p) = m**3
    # (n + p) = m**3 / n**2
    # p = (m**3 - n**3) / n**2
    # n is a cube, a**3
    # Cubes where the difference between them is a multiple of n**2

    found = 0

    for p in primes:
        # Find two cubes that have a difference of p
        lowerCube = 1
        upperCube = 2

        while 1:
            diff = upperCube**3 - lowerCube**3
#            print diff
            if diff > p:
                lowerCube += 1
                if lowerCube == upperCube:
                    # Couldn't find
                    break
            elif diff < p:
                upperCube += 1
            else:
                # Found
                found += 1
                break

    return found
Ejemplo n.º 5
0
def working(limit):
    primes = list(sievedPrimes(limit))[1:]
    ans = list()
    for x in xrange(2, limit):
        s = sigma2(x, primes)
        if isSquare(s):
            print x
            ans.append(x)
    return ans
Ejemplo n.º 6
0
def challenge108():
    target = 1000
    primeLimit = 10000

    primes = list(sievedPrimes(primeLimit))[1:]

#    # Get suitable primeIndices
    indices = primeIndices((target * 2 - 1), 0, primes, 0)

    return indices
Ejemplo n.º 7
0
def challenge123():
    primes = list(sievedPrimes(250000))
    limit = 10**10
    for n in xrange(7038, len(primes), 2):
        p = primes[n]
        r = getRemainder(p, n)
        if r > limit:
            return n + 1
        n += 1
    return
Ejemplo n.º 8
0
def challenge214():
    limit = 40000000
    length = 25
    primes = list(sievedPrimes(limit))
    phis = totients(limit, primes[1:])
    total = 0
    for p in primes:
        if (p - 1) >= (2**(length - 2)):
            if totientChainLength(p, 0, length, phis):
                total += p

    return total
Ejemplo n.º 9
0
def semiprimes(n):
    primes = list(sievedPrimes(n // 2))[1:]
    nPrimes = len(primes)

    nTwos = 0
    for i in xrange(nPrimes):
        for j in xrange(i, nPrimes):
            if primes[i] * primes[j] >= n:
                break
            nTwos += 1

    return nTwos
Ejemplo n.º 10
0
def challenge130():

    limit = 14702 # Optimised value
    primes = set(sievedPrimes(limit))

    found = []

    for n in [n for n in xrange(5, limit, 2) if (n % 5 != 0) and n not in primes]:
        if (n-1) % A(n) == 0:
            found.append(n)

    return sum(found)
Ejemplo n.º 11
0
def R(k):
    primes = sievedPrimes(160002)
    primes.next()
    primes.next()

    facts = list()

    for p in primes:
        if pow(10, k, 9*p) == 1:
            facts.append(p)
            if len(facts) == 40: break

    return facts
Ejemplo n.º 12
0
def challenge069():
    limit = 1000000
    sp = list(sievedPrimes(limit))
    sp.remove(1)
    primes = dict([p, float(p) / (p - 1)] for p in sp)
    nPhi = [1.0] * limit
    for k, n in primes.items():
        current = k - 1
        while current < limit:
            nPhi[current] *= n
            current += k

    highest = max(nPhi)
    return nPhi.index(highest) + 1
Ejemplo n.º 13
0
def getNumTarget(limit):
    primes = sievedPrimes(limit)
    primes.next()
    primes.next()

    total = 2
    for p in primes:
        if p % 4 == 3:
            total += 1
        if (p * 4) < limit:
            total += 1
            if (p * 16) < limit:
                total += 1                

    return total
Ejemplo n.º 14
0
def challenge060():
#    primes = [1, 3, 7, 37, 73, 109, 673, 1093, 1097, 3109, 3673, 6733, 6737, 7109, 7673, 109673, 673109] 
    primes = list(sievedPrimes(10000))
    primes.remove(1)
    primes.remove(2)

    # Get all prime pairs that concatenate
    pairs = getPrimePairs(primes)

    # Generate prime numbers
#    answer = nextDigits([], 5, primes, 30000)
    answer = nextDigitsDict([], 5, pairs, 30000, set(pairs.keys()))

    if answer:
        answer = sum(answer)

    return answer
Ejemplo n.º 15
0
def challenge231():
    n = 20000000
    k = 15000000
    # Get the primes needed
    primes = sievedPrimes(n)
    # Remove 1
    primes.next()

    total = 0
    # Cycle through primes
    for p in primes:
        current = 1
        # Loop through indexes of p
        index = 1
        while 1:
            current *= p

            # Get numerator range
            # Get first multiple on or after n - k
            # Get first multiple before n
            numRange = (getFirstMultipleOnOrAfter(n - k + 1, current), 
                        getFirstMultipleOnOrBefore(n, current))

            # Get denominator range
            # Get first multiple on or after 1
            # Get first multiple before k
            denRange = (getFirstMultipleOnOrAfter(1, current),
                        getFirstMultipleOnOrBefore(k, current))

            # Record if either is in range
            inRange = False
            # Check each is in range,
            # If in range then get the number of multiples in range
            # Multiply by p and add to sum
            if numRange[0] <= numRange[1]:
                total += numInRange(numRange[0], numRange[1], current) * p
                inRange = True
            if denRange[0] <= denRange[1]:
                total -= numInRange(denRange[0], denRange[1], current) * p
                inRange = True

            if not inRange:
                break

    return total
Ejemplo n.º 16
0
def challenge050():
    limit = 1000000
    primes = list(sievedPrimes(limit - 1))
    knownPrimes = set(primes)
    del primes[0]
    nPrimes = len(primes)
    longest = 0
    answer = 0

    for start in xrange(0, nPrimes):
        for end in xrange(start + 1 + longest, nPrimes):
            total = sum(primes[start: end])
            if total >= limit: break

            if total in knownPrimes:
                longest = end - start + 1
                answer = total
        
    return answer
Ejemplo n.º 17
0
def challenge049():
    permutationPrimes = dict()
    for prime in [n for n in sievedPrimes(9999) if n > 999]:
        chars = string.join(sorted(list(str(prime))), "")
        if permutationPrimes.has_key(chars):
            permutationPrimes[chars] += [prime]
        else:
            permutationPrimes[chars] = [prime]

    # Remove those less than 2
    permutationPrimes = dict([(c, p) for c, p in permutationPrimes.iteritems() if len(p) > 2])

    for primes in permutationPrimes.itervalues():
        for p1 in primes:
            for p2 in [p for p in primes if p != p1]:
                diff = p2 - p1
                p3 = p2 + diff
                if p3 in primes:
                    return int(str(p1) + str(p2) + str(p3))
Ejemplo n.º 18
0
def challenge134():
    limit = 10**6
    primes = sievedPrimes(limit + (limit / 10))
    # Strip pre 5
    for r in xrange(3):
        primes.next()

    p1 = primes.next()
    S = 0
    for p2 in primes:
        if p1 > limit:
            break

        # f(target, current, step)
        n = f(p1, p2, p2)

        S += n

        p1 = p2
    return S
Ejemplo n.º 19
0
def totients(n, primes = None):
    # Get the primes
    if primes == None:
        primes = sievedPrimes(n)
        # Remove 1
        primes.next()

    # Get result grid
    ans = range(n + 1)

    # Set each prime to prime - 1
    for p in primes:
        # will only use even other than prime
        ans[p] = p - 1

        # Step through ans in steps of p
        for t in xrange(2 * p, n + 1, p):
            # Set to current - (current // p)
            ans[t] -= (ans[t] // p)

    return ans
Ejemplo n.º 20
0
def challenge128():
    primes = set(sievedPrimes(1000000))
    # Loop through the layers
    layer = 2
    current = 7
    found = [1, 2]
    maximum = 2000
    while len(found) < maximum:
        end = current + 6 * layer
        current += 1

        # first
        if nPrimes(primes, [end - current, 6 * layer + 1, 6 * layer + (6 * (layer + 1)) - 1]) == 3:
            found.append(current)

        # end
        if nPrimes(primes, [end - current, 6 * layer + 6 * (layer - 1) - 1, 6 * (layer + 1) - 1]) == 3:
            found.append(end)

        current = end
        layer += 1
    return found[maximum - 1]
Ejemplo n.º 21
0
def challenge027():

    limit = 999

    aMax = 0
    bMax = 0

    maximum = 1
    bS = list(sievedPrimes(limit + 1))
    for b in bS:
        for a in xrange(-b, limit + 1):
            n = 1
            while True:
                f = n * (n + a) + b
                if not isPrime(f): break
                n += 1

            if n > maximum:
                maximum = n
                aMax = a
                bMax = b
 
    return aMax * bMax
Ejemplo n.º 22
0
def challenge203():
    rows = 51

    nums = set()

    # Generate triangle
    row = [1] * rows
    while len(row) > 0:
        # Remove last
        row = row[:-1]
        
        for i in xrange(1, len(row)):
            row[i] += row[i - 1]

        nums.update(row)

    # Get maximum
    highest = max(nums)

    # Get primes up to root of highest
    primes = list([x**2 for x in sievedPrimes(int(highest**0.5) + 1)])[1:]

    squareFree = []

    for n in nums:
        free = True
        for p in primes:
            if p > n:
                break
            if n%p == 0:
                free = False
                break

        if free:
            squareFree.append(n)
            
    return sum(squareFree)
Ejemplo n.º 23
0
def slowButRight(limit):
    primes = set(sievedPrimes(limit))
    return [n for sq, n in ((squareSum(n), n) for n in xrange(limit, 0, -1) if n not in primes) if isSquare(sq)]
Ejemplo n.º 24
0
def challenge133():
    limit = 50
    divs = [prime for prime in list(sievedPrimes(100000))[1:] if not divs_repunit(prime, limit)]

    return sum(divs) + 3
Ejemplo n.º 25
0
def hamNums(maxPrime, limit):
    # generate primes without 1
    primes = list(sievedPrimes(maxPrime))[1:]

    found = set()
    return getHams(1, limit, primes) + 1