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)))