def solve():
total = 0
for prime in generate_primes():
if prime > 2000000:
return total
else:
total += prime
def pb7():
"""
Problem 7 : 10001st prime
See utils.generate_primes for prime generation.
We then (apart from writing the list on a file) get the last element of the list.
"""
n = 10001
lst_of_primes = utils.generate_primes(n)
# Casually writing some primes to be reused at some point
with open('./resources/primes.txt', 'w') as f:
for prime in lst_of_primes:
f.write(str(prime) + '\n')
return lst_of_primes[-1]
def add_primes(commands: Commands) -> Commands:
"""
Encode order of commands by rising consecutive prime numbers to their power
There cannot be any complex conjugates(!) - they will be added later
:param commands: original array of commands
:return: encoded array of commands
"""
for i, prime in zip(range(len(commands)), Utilities.generate_primes()):
cmd = commands[i]
if not cmd.imag:
commands[i] = prime**cmd.real
elif cmd.imag:
commands[i] = cmd.real + (prime**cmd.imag) * 1j
return commands
from utils import generate_primes
seq_length = 1800813
seq = [0, 1]
seq_set = set(seq)
for n in range(2, seq_length):
subtract = seq[n-2] - n
if subtract >= 0 and subtract not in seq_set:
seq.append(subtract)
seq_set.add(subtract)
else:
seq.append(seq[n-2] + n)
seq_set.add(seq[n-2] + n)
primes = set(generate_primes(max(seq_set)))
prime_count = 0
for num in seq:
if num in primes:
prime_count += 1
print(prime_count)
def solve():
generator = generate_primes()
for _ in range(10001):
current = next(generator)
return current
from utils import generate_primes
gifts = 5433000
delivered = 0
primes = set(generate_primes(gifts))
gift_iter = iter(range(0, gifts + 1))
for gift_index in gift_iter:
if '7' in str(gift_index):
closest_lower_prime = max((x for x in primes if x <= gift_index))
for _ in range(0, closest_lower_prime):
next(gift_iter, None)
else:
delivered += 1
print(delivered)
"""
The prime 41, can be written as the sum of six consecutive primes:
41 = 2 + 3 + 5 + 7 + 11 + 13
This is the longest sum of consecutive primes that adds to a prime below
one-hundred.
The longest sum of consecutive primes below one-thousand that adds to a prime,
contains 21 terms, and is equal to 953.
Which prime, below one-million, can be written as the sum of the most
consecutive primes?
"""
from utils import generate_primes
PRIMES = generate_primes(1000000)
PRIMES_SET = set(PRIMES)
longest_sequence, sequence_length = [], 0
# Truncating primes to the first 1000 primes is a heuristic to speed up the
# algorithm. No proof that this gives the correct answer (but it does in this
# case).
for i, _ in enumerate(PRIMES[:1000]):
for j in range(i + 1, len(PRIMES[:1000])):
if sum(PRIMES[i:j]) in PRIMES_SET and j - i > sequence_length:
#print len(PRIMES[i:j]), sum(PRIMES[i:j])
longest_sequence, sequence_length = PRIMES[i:j], len(PRIMES[i:j])
print sum(longest_sequence)
def get_nth_prime(n):
return tuple(generate_primes(n))[-1]