def circular_prime(n):
if d_count(n) == 1: return True
r = rotate(n)
while r != n:
if d_count(r) == d_count(n) and prime_t[r]:
r = rotate(r)
else: return False
return True
def pandigital9(n):
if d_count(n) != 9: return False
b = 0
while n > 0:
b |= 1 << (n % 10)
n //= 10
return b == 0b1111111110
from common import d_count, Watch
max_pan = 0
def pandigital9(n):
if d_count(n) != 9: return False
b = 0
while n > 0:
b |= 1 << (n % 10)
n //= 10
return b == 0b1111111110
Watch.start()
max_pan = 0
for n in range(1, 10000):
pandigital = 0
for i in range(1, 9):
p = n * i
pandigital = pandigital * 10**d_count(p) + p
if d_count(pandigital) >= 9:
if pandigital9(pandigital):
max_pan = max(max_pan, pandigital)
else: break
print(max_pan)
Watch.stop()
from common import prime_table, d_count, Watch
Watch.start()
lim = 1000000
prime_t = prime_table(lim)
def check_rotations(n, next_r):
while n > 10:
if prime_t[next_r(n)]: n = next_r(n)
else: return False
return prime_t[n]
count, sum, primes = 0, 0, [n for n in range(2, lim) if prime_t[n]]
left, right = lambda x: x // 10, lambda x: x % 10 ** (d_count(x) - 1)
for prime in primes[4:]:
if check_rotations(prime, left) and check_rotations(prime, right):
sum += prime
count += 1
if count == 11: break
print(sum)
Watch.stop()
from collections import defaultdict
import sys
from common import is_prime, Watch, sieve_primes, d_count
Watch.start()
lim = 10000
primes, cat, graph = list(sieve_primes(lim)), lambda x, y: x * 10 ** d_count(y) + y, defaultdict(set)
primes.remove(2)
primes.remove(5)
for i, p1 in enumerate(primes):
for p2 in primes[i + 1:]:
if is_prime(cat(p1, p2)) and is_prime(cat(p2, p1)):
graph[p1].add(p2)
max_sum = sys.maxsize
for a in primes:
xa = graph[a]
for b in xa:
xb = xa & graph[b]
for c in xb:
xc = xb & graph[c]
for d in xc:
xd = xc & graph[d]
for e in xd:
max_sum = min(max_sum, a + b + c + d + e)
print(max_sum)
Watch.stop()
def rotate(n):
q, r = divmod(n, 10 ** (d_count(n) - 1))
return r * 10 + q
from itertools import count
from common import d_count, Watch
Watch.start()
c = 1
for d in range(2, 10):
for p in count(1):
length = d_count(d ** p)
if p == length: c += 1
if p > length: break
print(c)
Watch.stop()
from common import Watch, d_count
def pandigital9(n):
if d_count(n) != 9: return False
b = 0
while n > 0:
b |= 1 << (n % 10)
n //= 10
return b == 0b1111111110
Watch.start()
products = set()
for a in range(123, 9877):
for b in range(1, 99):
p = a * b
n = (a * 10 ** d_count(b) + b) * 10 ** d_count(p) + p
if pandigital9(n): products.add(p)
print(sum(products))
Watch.stop()
from common import Watch, d_count
Watch.start()
a, b, count = 0, 1, 0
for _ in range(1000):
if d_count(a + b) > d_count(b): count += 1
a, b = b, 2 * b + a
print(count)
Watch.stop()
def gen_squares(length):
n, square, squares = 36, 1296, defaultdict(set)
while d_count(square) < length:
square, n = n * n, n + 1
squares[d_count(square)].add(square)
return squares
