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]
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
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
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
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
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
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
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
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
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]
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
def run(): primes = euler.primesUpTo(125000) return primes[10000]
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)
def run(): return sum(euler.primesUpTo(2000000))
def run(): return hammingCount(euler.primesUpTo(100), 0, 1)
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]))