def prime_pairs(prime):
# Return the primes lower than the given prime that meet the concat
# requirement.
return {paired_prime for paired_prime in primes.range(prime - 1)
if meets_concat_requirement(prime, paired_prime)}
digits 1 to n exactly once. For example, 2143 is a 4-digit pandigital and is
also prime.
What is the largest n-digit pandigital prime that exists?
'''
from sequence import consume
from prime import primes
PANDIGITAL_SETS = {n: frozenset(str(i) for i in range(1, n + 1))
for n in range(1, 10)}
def is_pandigital(num):
string = str(num)
return set(string) == PANDIGITAL_SETS[len(string)]
# The largest possible pandigital number is 987,654,321. However no nine-digit
# pandigital number is prime, as the sum of the digits 1-9 is 45, so all such
# numbers can be divided by 9. The same applies to eight-digit pandigital
# numbers.
#
# So a sketch design presents itself: generate primes up to 7,654,321, then
# return the largest of these that is also pandigital.
if __name__ == '__main__':
consume(primes.range(7654321))
print(next(prime for prime in reversed(primes.history)
if is_pandigital(prime)))
return []
solutions = []
for prime in s2:
solutions.extend(recurse(goal, s1 | {prime}, s2 & pairs[prime], pairs))
return solutions
if __name__ == '__main__':
try:
goal = int(sys.argv[1])
except IndexError:
goal = 5
pairs = {}
answer = sys.maxsize # Well above the actual result, so we can use `min`
for prime in primes.range(3, None):
if prime > answer:
# This prime is greater than the best answer we have, so this prime
# and higher primes cannot possibly produce a better answer.
break
pairs[prime] = prime_pairs(prime)
results = recurse(goal, {prime}, pairs[prime], pairs)
if results:
# It turns out the first answer this algorithm produces is correct,
# but it doesn't take very long to verify this, so we don't break
# out of the loop until we're actually confident the answer is
# right.
answer = min([answer] + [sum(result) for result in results])
print(answer)
def prime_triples():
for prime_one in primes.range(1000, 9999):
for prime_two in primes.range(prime_one + 1, 9999):
if prime_two + (prime_two - prime_one) in primes:
# Arithmetic sequence of primes.
yield prime_one, prime_two, prime_two + (prime_two - prime_one)
stage: 3797, 797, 97, and 7. Similarly we can work from right to left: 3797,
379, 37, and 3.
Find the sum of the only eleven primes that are both truncatable from left to
right and right to left.
NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes.
'''
from prime import primes
def truncatable_prime(prime):
string = str(prime)
for i in range(1, len(string)):
if int(string[i:]) not in primes:
return False
if int(string[:-i]) not in primes:
return False
return True
if __name__ == '__main__':
truncatable_primes = []
for prime in primes.range(10, None):
if truncatable_prime(prime):
truncatable_primes.append(prime)
if len(truncatable_primes) >= 11:
break
print(sum(truncatable_primes))
also prime.
What is the largest n-digit pandigital prime that exists?
'''
from prime import primes
PANDIGITAL_SETS = {
n: frozenset(str(i) for i in range(1, n + 1))
for n in range(1, 10)
}
def is_pandigital(num):
string = str(num)
return set(string) == PANDIGITAL_SETS[len(string)]
# The largest possible pandigital number is 987,654,321. However no nine-digit
# pandigital number is prime, as the sum of the digits 1-9 is 45, so all such
# numbers can be divided by 9. The same applies to eight-digit pandigital
# numbers.
#
# So a sketch design presents itself: generate primes up to 7,654,321, then
# return the largest of these that is also pandigital.
if __name__ == '__main__':
print(
next(prime for prime in reversed(list(primes.range(7654321)))
if is_pandigital(prime)))
def prime_triples():
for prime_one in primes.range(1000, 9999):
for prime_two in primes.range(prime_one + 1, 9999):
if prime_two + (prime_two - prime_one) in primes:
# Arithmetic sequence of primes.
yield prime_one, prime_two, prime_two + (prime_two - prime_one)
# False, True, True, False).
for replacements in product((True, False), repeat=len(prime_string)):
# Skip if we're replacing all or none of the digits, since that's not
# interesting, and also skip if not all the digits being replaced are
# equal, since in that case the prime we're looking at isn't one of the
# primes we'll generate.
if (all_equal(replacements) or
not all_equal(compress(prime_string, replacements))):
continue
# Allow replacement with 0 only if the first digit isn't one that's
# being replaced.
if replacements[0]:
replacement_digits = '123456789'
else:
replacement_digits = '0123456789'
if sum(int(replace_digits(prime_string, replacements, digit)) in primes
for digit in replacement_digits) >= 8:
return True
# Tried all the possible ways to replaced digits without finding a
# solution.
return False
if __name__ == '__main__':
for prime in primes.range(56004, None):
if test_prime(prime):
print(prime)
break
379, 37, and 3.
Find the sum of the only eleven primes that are both truncatable from left to
right and right to left.
NOTE: 2, 3, 5, and 7 are not considered to be truncatable primes.
'''
from prime import primes
def truncatable_prime(prime):
string = str(prime)
for i in range(1, len(string)):
if int(string[i:]) not in primes:
return False
if int(string[:-i]) not in primes:
return False
return True
if __name__ == '__main__':
truncatable_primes = []
for prime in primes.range(10, None):
if truncatable_prime(prime):
truncatable_primes.append(prime)
if len(truncatable_primes) >= 11:
break
print(sum(truncatable_primes))
#!/usr/bin/env python3
'''
Summation of primes
The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.
Find the sum of all the primes below two million.
'''
from sys import argv
from prime import primes
if __name__ == '__main__':
try:
target = int(argv[1])
except IndexError:
target = 2000000
print(sum(primes.range(target + 1)))
