Example #1
0
def run():
    limit = 100000
    primes = [p for p in euler.primesUpTo(limit)]
    radical = [1]*(limit+1)
    for p in primes:
        for n in range(p, limit+1, p):
            radical[n] *= p
    return sorted([(radical[n], n) for n in range(1, limit+1)])[9999][1]
Example #2
0
def run():
    n, total = 0, 0
    for p in euler.primesUpTo(1000000):
        if pow(10, 1000000000, 9*p) == 1:
            n += 1
            total += p
        if n == 40:
            break
    return total
Example #3
0
def run():
    limit = 1000000
    primes = euler.primesUpTo(limit)
    seq = [primes[0]]
    n, max_seq, max_sum = 0, 0, 0
    while seq[n] < limit:
        seq.append(seq[n] + primes[n+1])
        n += 1
    for i in range(n, 0, -1):
        for j in range(i):
            if i - j > max_seq and seq[i] - seq[j] in primes:
                max_seq = i - j
                max_sum = seq[i] - seq[j]
    return max_sum
Example #4
0
def run():
    primes = {}
    for prime in euler.primesUpTo(1000000):
        primes[str(prime)] = prime
    total = 0
    for key in primes:
        circular = True
        for i in range(1, len(key)):
            if key[i:]+key[0:i] not in primes:
                circular = False
                break
        if circular:
            total += 1
    return total
Example #5
0
def run():
    primes = set(euler.primesUpTo(10000))
    for n in range(1000, 10000):
        perms = []
        for num in sorted(set(map("".join, itertools.permutations(str(n))))):
            x = int(num)
            if x in primes and x >= 1000:
                perms.append(x)
        if len(perms) < 3:
            continue
        for triple in itertools.combinations(perms, 3):
            if triple[1]-triple[0] == triple[2]-triple[1] and triple[0] != 1487:
                return int(''.join([str(n) for n in triple]))
    return 0
Example #6
0
def run():
    primes = {}
    for prime in euler.primesUpTo(1000000):
        primes[str(prime)] = prime
    total = 0
    for key in primes:
        if len(key) == 1:
            continue
        truncatable = True
        for i in xrange(1, len(key)):
            if key[i:] not in primes or key[0:len(key)-i] not in primes:
                truncatable = False
                break
        if truncatable:
            total += primes[key]
    return total
Example #7
0
def run():
    primes = euler.primesUpTo(100000000)
    strPrimes = {str(prime): prime for prime in primes}
    pairs = {}
    for prime in primes:
        s = str(prime)
        for i in range(1, len(s)):
            if s[i] == "0":
                continue
            if s[0:i] not in strPrimes:
                continue
            if s[i:] not in strPrimes:
                continue
            if s[i:]+s[0:i] in strPrimes:
                p = int(s[0:i])
                q = int(s[i:])
                if p in pairs:
                    pairs[p].add(q)
                else:
                    pairs[p] = set([p, q])
                if q in pairs:
                    pairs[q].add(p)
                else:
                    pairs[q] = set([q, p])
    keys = sorted([k for k in list(pairs.keys()) if len(pairs[k]) >= 5])
    for a in range(0, len(keys)):
        aa = pairs[keys[a]]
        for b in range(a+1, len(keys)):
            bb = pairs[keys[b]].intersection(aa)
            if len(bb) < 5:
                continue
            for c in range(b+1, len(keys)):
                cc = pairs[keys[c]].intersection(bb)
                if len(cc) < 5:
                    continue
                for d in range(c+1, len(keys)):
                    dd = pairs[keys[d]].intersection(cc)
                    if len(dd) < 5:
                        continue
                    for e in range(d+1, len(keys)):
                        ee = pairs[keys[e]].intersection(dd)
                        if len(ee) < 5:
                            continue
                        return sum(ee)
    return 0
Example #8
0
def run():
    primes = set([p for p in euler.primesUpTo(1000000)])
    largest = 0
    max_product = 0
    for b in range(0, 1000):
        for a in range(-999, 1000):
            n = 0
            while True:
                num = n*(a+n)+b
                if num < 2:
                    break
                if num not in primes:
                    break
                n += 1
            if n > largest:
                largest = n
                max_product = a*b
    return max_product
Example #9
0
def run():
    primes = euler.primesUpTo(18097)
    pascals = set()

    for n in range(0, 50):
        for k in range(0, n//2+1):
            pascals.add(euler.choose(n, k))

    total = 0
    for pascal in pascals:
        squarefree = True
        for prime in primes:
            if pascal % (prime*prime) == 0:
                squarefree = False
                break
        if squarefree:
            total += pascal

    return total
Example #10
0
def run():
    digits, size = 6, 8
    lower, upper = 10**(digits-1), 10**digits
    primes = set(euler.primesUpTo(upper))
    patterns = [[x, y, z] for x in xrange(0, digits-1) for y in xrange(0, digits-1) for z in xrange(0, digits-1) if x < y and y < z]
    for n in [p for p in primes if p >= lower]:
        for indices in patterns:
            s = list(str(n))
            family = []
            for d in xrange(0, 10):
                for i in indices:
                    s[i] = str(d)
                # skip values with leading zeroes
                if s[0] == '0':
                    continue
                x = int(''.join(s))
                if x in primes:
                    family.append(x)
            if len(family) == size:
                return family[0]
Example #11
0
def run():
    limit = 10000000
    primes = euler.primesUpTo(limit)
    min_n = 0
    min_ratio = limit

    for i in range(0, len(primes)):
        for j in range(i, len(primes)):
            semiprime = primes[i] * primes[j]
            if semiprime >= limit:
                break
            if i == j:
                phi = primes[i] * (primes[j]-1)
            else:
                phi = (primes[i]-1) * (primes[j]-1)
            if sorted(list(str(semiprime))) != sorted(list(str(phi))):
                continue
            ratio = float(semiprime) / float(phi)
            if ratio < min_ratio:
                min_ratio = ratio
                min_n = semiprime
    return min_n
Example #12
0
def run():
    primes = euler.primesUpTo(125000)
    return primes[10000]
Example #13
0
import euler

if __name__ == "__main__":
    primes = set([p for p in euler.primesUpTo(1000000)])
    largest = 0
    max_product = 0
    for b in xrange(0, 1000):
        for a in xrange(-999, 1000):
            n = 0
            while True:
                num = n * (a + n) + b
                if num < 2:
                    break
                if num not in primes:
                    break
                n += 1
            if n > largest:
                largest = n
                max_product = a * b
    print(max_product)
Example #14
0
def run():
    return sum(euler.primesUpTo(2000000))
Example #15
0
def run():
    return hammingCount(euler.primesUpTo(100), 0, 1)
Example #16
0
def run():
    limit = 50000000
    primes2 = [p**2 for p in euler.primesUpTo(int(math.ceil(nth_root(2, limit))))]
    primes3 = [p**3 for p in euler.primesUpTo(int(math.ceil(nth_root(3, limit))))]
    primes4 = [p**4 for p in euler.primesUpTo(int(math.ceil(nth_root(4, limit))))]
    return len(set([x+y+z for x in primes2 for y in primes3 for z in primes4 if x+y+z < limit]))