def concatproduct(n): digits = [] for i in range(1, 10): digits += intToDigits(n * i) if len(digits) >= 9: break if pandigital9(digitsToInt(digits)): return digitsToInt(digits) return 0
def truncatable(prime): dig = intToDigits(prime) for i in range(1, len(dig)): trunc_r = digitsToInt(dig[:i]) if trunc_r not in sieve: return False trunc_l = digitsToInt(dig[i:]) if trunc_l not in sieve: return False return True
def familysize(p): if not repeatingdigits(p): return 1 dig = intToDigits(p) bestfamily = [p] for oldd in set(dig) - {dig[-1]}: family = [p] if len([d for d in dig if d == oldd]) < 2: continue for newd in set(range(10)) - {oldd}: if newd == 0 and dig[0] == oldd: continue newp = digitsToInt([newd if d == oldd else d for d in dig]) if newp in sieve: family.append(newp) if len(family) > len(bestfamily): bestfamily = family for pr in bestfamily: memoize[pr] = len(bestfamily) if len(bestfamily) == 8: print(bestfamily) return len(bestfamily)
def rotations(n): dig = intToDigits(n) for i in range(1, len(dig)): yield digitsToInt(dig[i:] + dig[:i])
def concatprime(p1,p2): d1 = intToDigits(p1) d2 = intToDigits(p2) c1 = digitsToInt(d1+d2) c2 = digitsToInt(d2+d1) return isprime(c1) and isprime(c2)
EXPLANATION: fractions package allows us to keep generating. """ from Euler.tictoc import tic, toc from Euler.eprint import eprint from fractions import Fraction as f from itertools import islice from Euler.digits import intToDigits def gen(): i = 2 while True: yield 1 yield i yield 1 i += 2 if __name__ == "__main__": tic() convergents = reversed(list(islice(gen(), 99))) F = f(1, next(convergents)) for c in convergents: F = f(1, c + F) F = 2 + F print(sum(intToDigits(F.numerator))) toc() exit()
#!/usr/bin/env python3.6 """ PROBLEM: 092 AUTHOR: Dirk Meijer STATUS: done EXPLANATION: look ma, no proper tail call optimization! """ from Euler.tictoc import * from Euler.digits import intToDigits from functools import reduce next = lambda n: reduce(lambda S, d: S + d * d, intToDigits(n), 0) memoize = [None] * 10_000_001 memoize[1] = 1 memoize[89] = 89 def chain(*c): n = next(c[0]) m = memoize[n] if m: for a in c: memoize[a] = m return else: chain(n, *c) if __name__ == "__main__":
def dig(): yield 0 for n in range(1, 1_000_000): for d in intToDigits(n): yield d
from math import ceil, log2 def palindromicInBinary(n): binary = bin(n)[2:] for a, b in zip(binary, reversed(binary)): if a != b: return False return True if __name__ == "__main__": tic() S = 0 for i in range(1, 1000, 2): digits = intToDigits(i) p = digitsToInt(list(reversed(digits)) + digits) #even length: cbaabc if palindromicInBinary(p): S += p p = digitsToInt(list(reversed(digits)) + digits[1:]) #odd length: cbabc if palindromicInBinary(p): S += p if i < 100: #center zeros: cb00bc p = digitsToInt(list(reversed(digits)) + [0] + digits) if palindromicInBinary(p): S += p p = digitsToInt(list(reversed(digits)) + [0, 0] + digits) if palindromicInBinary(p): S += p if i < 10: #center zeros: cb00bc
def repeatingdigits(n): from math import floor, log10 d = intToDigits(n) return len(set(d)) <= floor(log10(n))
first digit must be a one. assuming unique digits. """ from Euler.tictoc import tic, toc from Euler.eprint import eprint from Euler.digits import intToDigits, digitsToInt def repeatingdigits(n): from math import floor, log10 d = intToDigits(n) return len(set(d)) <= floor(log10(n)) if __name__ == "__main__": tic() for x_ in range(10**4, 10**7): dig = [1] + intToDigits(x_) x = digitsToInt(dig) if repeatingdigits(x): continue if sorted(intToDigits(2 * x)) == sorted(dig): if sorted(intToDigits(3 * x)) == sorted(dig): if sorted(intToDigits(4 * x)) == sorted(dig): if sorted(intToDigits(5 * x)) == sorted(dig): if sorted(intToDigits(6 * x)) == sorted(dig): print(x) toc() exit()
straightforward search. knowing the lower limit reduces search time, but taking a naive approach takes almost 2 minutes. """ from Euler.tictoc import tic, toc from Euler.eprint import eprint from Euler.digits import ispermutation, intToDigits if __name__ == "__main__": tic() lower = 4000 upper = 10000 for n1 in range(lower, upper): c1 = n1 * n1 * n1 dig = len(intToDigits(c1)) for n2 in range(n1 + 1, upper): c2 = n2 * n2 * n2 if len(intToDigits(c2)) > dig: break if not ispermutation(c1, c2): continue for n3 in range(n2 + 1, upper): c3 = n3 * n3 * n3 if len(intToDigits(c3)) > dig: break if not ispermutation(c2, c3): continue for n4 in range(n3 + 1, upper): c4 = n4 * n4 * n4 if len(intToDigits(c4)) > dig:
#!/usr/bin/env python3.6 """ PROBLEM: 015 AUTHOR: Dirk Meijer STATUS: done EXPLANATION: library solution """ from Euler.tictoc import * from Euler.digits import intToDigits if __name__=="__main__": tic() print(sum(intToDigits(2**1000))) toc() exit()
#!/usr/bin/env python3 """ PROBLEM: 063 AUTHOR: Dirk Meijer STATUS: done EXPLANATION: ezpz """ from Euler.tictoc import tic,toc from Euler.eprint import eprint from Euler.digits import intToDigits from math import log if __name__=="__main__": tic() S = 0 for exponent in range(1,25): for base in range(1,25): n = pow(base,exponent) d = len(intToDigits(n)) if d == exponent: S += 1 if d > exponent: break print(S) toc() exit()
#!/usr/bin/env python3.6 """ PROBLEM: 034 AUTHOR: Dirk Meijer STATUS: done EXPLANATION: pythonic """ from Euler.tictoc import * from Euler.digits import intToDigits from math import factorial if __name__ == "__main__": tic() print( sum([ n for n in range(10, 100000) if n == sum(map(factorial, intToDigits(n))) ])) toc() exit()
#!/usr/bin/env python3.6 """ PROBLEM: 030 AUTHOR: Dirk Meijer STATUS: done EXPLANATION: brute force, arbitrary upperbound at 2e5 """ from Euler.tictoc import * from Euler.digits import intToDigits if __name__=="__main__": tic() print(sum({n for n in range(1,200000) if sum(map(lambda d: pow(d,5),intToDigits(n)))==n})) toc() exit()