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]