def solve():
accum = 0
for p in primeIter(bound=n//2):
ppows = list(powers(p,n))
for q in primeIter(bound=min(p-1,n//p)):
accum += max(pk * last(powers(q, n//pk))
for pk in ppows if q <= n//pk)
return accum
def solve():
bound = 1000
primes = list(primeIter(bound=bound))
n = 2
while primesums(n) <= 5000:
n += 1
if n >= bound:
bound *= 10
primes = list(primeIter(bound=bound))
return n
def solve():
maxPrimes = 40
maxCoefProd = 41
for b in dropwhile(lambda p: p<=41, primeIter(bound=1000)):
for a in xrange(-999, 1000):
if a == b+1 or a == b-1:
# The quadratic can be factored into (n ± b)(n ± 1) and so will
# produce no more than 2 consecutive primes.
continue
if a*a >= 4*b:
bound = b
d = sqrt(a*a - 4*b)
x1 = (-a+d)/2
x2 = (-a-d)/2
if 0 < x1 < bound:
bound = x1
if 0 < x2 < bound:
bound = x2
if bound <= maxPrimes:
continue
n = 1
while isPrime(n*n + a*n + b):
n += 1
if n > maxPrimes:
maxPrimes = n
maxCoefProd = a*b
return maxCoefProd
def solve():
n = 1
for p in primeIter(bound=1000):
np = n * p
if np <= 1000000:
n = np
else:
break
return n
def solve():
accum = 0
for n1 in primeIter(bound=100000000):
n = n1 - 1
for d in xrange(2, int(n**0.5)+1):
if n % d == 0 and not isPrime(d + n // d):
break
else:
accum += n
return accum
def solve():
primePerms = defaultdict(list)
for p in dropwhile(lambda n: n<1000, primeIter(bound=10000)):
primePerms[''.join(sorted(str(p)))].append(p)
for perms in primePerms.itervalues():
if len(perms) >= 3 and 1487 not in perms:
for i,p1 in enumerate(perms[:-2]):
for j,p2 in enumerate(perms[i+1:-1]):
p3 = p2 + p2 - p1
if p3 in perms[j+i+2:]:
return '%d%d%d' % (p1, p2, p3)
def solve():
primes = tuple(primeIter(bound=100))
qty = 1
queue = deque([(1,0)])
while queue:
(n, pi) = queue.popleft()
for j in xrange(pi, len(primes)):
m = n * primes[j]
if m <= limit:
queue.append((m,j))
qty += 1
return qty
def solve():
piter = primeIter(bound = VERY VERY BAD IDEA: supN**2 + 28)
consecutive = (next(piter), next(piter), next(piter),
next(piter), next(piter), next(piter))
accum = 0
for n in xrange(10, supN, 2):
if n % 3 == 0 or n % 7 in (0,3,4) or n % 13 == 0:
continue
sq = n*n
while sq+1 > consecutive[0]:
consecutive = consecutive[1:] + (next(piter),)
if tuple(sq+o for o in offsets) == consecutive:
accum += n
return accum
def solve():
samTotal = 0
maxTotal = 0
for n in dropwhile(lambda x: x <= 10**7, primeIter(bound=2*10**7)):
prev = set()
while True:
digits = map(int, str(n))
screen = set((i,s) for (i,d) in enumerate(reversed(digits))
for s in segments[d])
samTotal += 2 * len(screen)
maxTotal += len(prev ^ screen)
prev = screen
if n < 10:
break
else:
n = sum(digits)
maxTotal += len(prev)
return samTotal - maxTotal
def solve():
maxPrime = 0
maxTerms = 0
primes = list(primeIter(bound=10**6))
for i,p in enumerate(primes):
try:
accum = sum(primes[i+j] for j in xrange(maxTerms))
except IndexError:
break
if accum >= 1000000:
break
for j in xrange(maxTerms, len(primes)-i):
accum += primes[i+j]
if accum >= 1000000:
break
if isPrime(accum):
maxPrime = accum
maxTerms = j+1
return maxPrime
def solve():
piter = primeIter(bound=10**8)
next(piter)
next(piter)
return sum(S(p) for p in piter)
def solve():
return sum(p * (facdiv(n,p) - facdiv(r,p) - facdiv(n-r,p))
for p in primeIter(bound=n))
def solve():
n = 10001
sieve(ceil(n*log(n) + n*log(log(n))))
return nth(primeIter(), n-1)
def solve():
return sum(itertools.ifilter(length25, primeIter(bound=40000000)))
def solve():
return sum(ilen(primeIter(bound=min(p,n//p))) for p in primeIter(bound=n//2))
def solve():
return sum(primeIter(bound=2000000))
