def find(n: int):
primes = [p for p in range(1237, 9874) if lib.is_prime(p)]
primes = [((p, set(lib.digits(p))), (q, set(lib.digits(q)))) for p in primes for q in primes if q > p]
arithm = {}
answer = set()
for P, Q in primes:
p, dp = P
q, dq = Q
if dp != dq:
continue
else:
key = (tuple(sorted(dp)), q - p)
if key in arithm:
arithm[key].update({p, q})
else:
arithm[key] = {p, q}
if len(arithm[key]) == 3:
s = int("".join(map(str, sorted(arithm[key]))))
answer.add(s)
else:
return list(answer - {148748178147})[0]
def digit_cancelling_fractions():
lowest_nums = []
lowest_denoms = []
for den in range(10, 100):
if den % 10 == 0:
continue
for num in range(10, den):
num_digits = eulerlib.digits(num)
den_digits = eulerlib.digits(den)
if num % 10 == 0:
continue
digits_intersection = list(set(num_digits) & set(den_digits))
if len(digits_intersection) > 0:
num_digits.remove(digits_intersection[0])
den_digits.remove(digits_intersection[0])
num_lct = eulerlib.digits_to_int(num_digits)
den_lct = eulerlib.digits_to_int(den_digits)
cancelled_fraction = num_lct / den_lct
fraction = num / den
if fraction == cancelled_fraction:
lowest_nums.append(num_lct)
lowest_denoms.append(den_lct)
print('{} / {} = {} / {}'.format(num, den, num_lct, den_lct))
num_prod = eulerlib.product(lowest_nums)
den_prod = eulerlib.product(lowest_denoms)
gcd = eulerlib.gcd(num_prod, den_prod)
return den_prod / gcd
def find() -> set:
rng = set(range(1, 10))
res = set()
for a in range(1, 100):
da = lib.digits(a)
if not unique(da): continue
for b in range(100, 10_000):
db = da + lib.digits(b)
if not unique(db): continue
c = a * b
dc = db + lib.digits(c)
if unique(dc) and set(dc) == rng:
res.add(c)
print(f"{a} x {b} = {c}")
def pandigital_multiples():
pandigitals = []
for i in range(1, 10000):
digits = el.digits(i)
j = 2
while len(digits) < 9:
digits += el.digits(i * j)
j += 1
if len(digits) == 9 and el.is_pandigital_to_n(digits, 9):
print('Pandigital: {}'.format(digits))
pandigitals.append(el.digits_to_int(digits))
return max(pandigitals)
def pandigital_products():
res = 0
memo = []
bound = 10000
set_of_1_to_9 = set(range(1, 10))
for a in range(2, bound):
log10a = math.log(a, 10)
inner_exp = 7/2 - log10a
if not eulerlib.is_unique_string(str(a)):
continue
lower_bound_for_b = int(10**inner_exp)
for b in range(lower_bound_for_b, 10*lower_bound_for_b):
log10b = math.log(b, 10)
log10c = log10a + log10b
log_digits = int(log10a + log10b + log10c)
if log_digits != 7:
continue
c = a * b
mmi = int(str(a) + str(b) + str(c))
digits_of_mmi = eulerlib.digits(mmi)
if c not in memo and set(digits_of_mmi) == set_of_1_to_9:
print('{} x {} = {} ({})'.format(a, b, c, mmi))
res += c
memo.append(c)
return res
def digit_powers(n):
numbers = [
i for i in range(2, 9**n * n + 1)
if sum(map(lambda x: x**n, eulerlib.digits(i))) == i
]
print('Numbers found: {}'.format(numbers))
return sum(numbers)
def pattern(n: int):
p = {}
for d in lib.digits(n):
try:
p[d] += 1
except KeyError:
p[d] = 1
else:
return p
def find():
n = 10
s = set()
while u(n):
if n == sum(math.factorial(d) for d in lib.digits(n)):
s.add(n)
n += 1
else:
return s
def prime_permutations():
N = 10000
S = eulerlib.prime_sieve(N)
P = [p for p in eulerlib.sieve_to_list(S) if 1000 < p < 9999]
print('p1 p2 p3 d')
print('------------------------')
for p1 in P:
d = 1
while p1 + 2 * d < N:
p2 = p1 + d
p3 = p2 + d
if S[p1] and S[p2] and S[p3] and is_permutation3(
eulerlib.digits(p1), eulerlib.digits(p2),
eulerlib.digits(p3)):
print(p1, p2, p3, d)
break
d += 1
def D(n: int):
k = 1
d = 0
m = 0
while k + d <= n:
k += d
d = (m + 1) * 9 * pow(10, m)
m += 1
else:
q, r = divmod(n - k, m)
return lib.digits(pow(10, m - 1) + q)[r]
def circular_primes():
sieve = eulerlib.prime_sieve(1000000)
primes = [i for i, v in enumerate(sieve) if v]
result = 0
for p in primes:
is_circular_prime = True
prime_c = eulerlib.digits(p)
for _ in range(len(prime_c) - 1):
prime_c = eulerlib.shift(prime_c)
if not sieve[eulerlib.digits_to_int(prime_c)]:
is_circular_prime = False
break
if is_circular_prime:
print(p)
result += 1
return result
def pdr(max_n):
result = {}
memo = {}
for i in range(13, max_n):
if not sieve[i] and i % 11 != 0:
continue
print('Testing: {}'.format(i))
istr = str(i)
perms = perm(lib.digits(istr), len(istr))
for p in perms:
if p in memo.keys():
continue
memo[p] = True
count = 0
for j in range(0, 10):
if j == 0 and p[0] == '*':
continue
pnum = int(p.replace('*', str(j)))
if sieve[pnum]:
count += 1
result[p] = count
if count == 8:
print('Smallest prime with eight prime value family is {} with permutation {}'.format(i, p))
exit(0)
def test_digits(self):
assert eulerlib.digits(123) == [1, 2, 3]
def main(n: int):
return sum(lib.digits(e(n)[1]))
def convergents_of_e():
an = [2]
for k in range(1, 34):
an += [1, 2 * k, 1]
cf = ContinuedFraction(an)
return sum(digits(cf.pn(99)))
