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