Example #1
0
def is_pandigital(n):
    i = 1
    digits_count = [0] * 10
    while digits_count.count(1) != 9:
        for digit in digits(n * i):
            if digit == 0 or digits_count[digit] > 1:
                return (False, 0)
            else:
                digits_count[digit] += 1
        i += 1
    num = "".join("".join(str(d) for d in digits(n * j)[::-1]) for j in range(1, i))
    return (True, num)
Example #2
0
def stop89(n):
    if n == 1: return False
    if n == 89: return True
    if n in memo: return memo[n]
    result = stop89(sumsq(digits(n)))
    memo[n] = result
    return result
Example #3
0
def isPowerSum_s(s, x):
    _, d = digits(s ** x)
    if sum(d) == s:
        print(s, x, s**x)
        return True
    else:
        return False
Example #4
0
def problem16():
    """
    215 = 32768 and the sum of its digits is 3 + 2 + 7 + 6 + 8 = 26.

    What is the sum of the digits of the number 2^1000?
    """
    return sum(util.digits(2**1000))
Example #5
0
def stop89(n):
    if n == 1: return False
    if n == 89: return True
    if n in memo: return memo[n]
    result = stop89(sumsq(digits(n)))
    memo[n] = result
    return result
Example #6
0
def keep_10_multiply(a, b):
    r = a * b
    num, ds = digits(r)
    if num > 10:
        ds = ds[-10:]
    keep_10 = int(''.join(map(str, ds)))
    return keep_10
Example #7
0
def is_pandigital_product(a, b):
    """Determine whether a * b is a pandigital product."""
    missing = [True]*9
    pandigits = [1, 2, 3, 4, 5, 6, 7, 8, 9]

    if a*b < 10**8:
        total_digits = digits(a) + digits(b) + digits(a*b)

        if len(total_digits) != 9:
            return False
        for d in total_digits:
            if d == 0:
                return False
            missing[d-1] = False

    return not any(missing)
Example #8
0
def chainEnds(n):
    # chains = []
    while n != 1 and n != 89:
        _, allDigits = digits(n);
        n = sum([x**2 for x in allDigits])
        # chains.append(n)
    # return chains
    return n
Example #9
0
def bouncy(x):
    digs = digits(x)
    up, down = False, False
    for i in range(1,len(digs)):
        if digs[i-1] < digs[i]:
            down = True
        elif digs[i-1] > digs[i]:
            up = True
        if up and down:
            return True
    return False
Example #10
0
def is_pandigital(n):
    [num, ds] = digits(n)
    p = [True] * num
    for d in ds:
        if d == 0 or d > num:
            break
        else:
            p[d-1] = False
    # print n, p
    if len(filter(lambda x: x, p)) == 0:
        return True
    else:
        return False
Example #11
0
def isBouncyNumber(n):
    numDigits, digitList = digits(n)
    if numDigits < 2:
        return False
    index = 0
    trend = 0
    while trend == 0 and index < numDigits-1:
        trend = digitList[index] - digitList[index+1]
        index += 1
    # print(trend, index)
    for i in range(index, numDigits-1):
        t = digitList[i] - digitList[i+1]
        if t * trend < 0: 
            return True
    return False
Example #12
0
def is_truncatable_prime(n):
    num, ds = digits(n)
    # remove digits from left to right
    for i in xrange(1, len(ds)):
        tmp_ds = ds[i:]
        tmp_n = int(reduce(lambda x, y: ''.join([str(x), str(y)]), tmp_ds, ''))
        if not is_prime(tmp_n):
            return False
    # remove digits from right to left
    for i in xrange(1, len(ds)):
        tmp_ds = ds[:len(ds)-i]
        tmp_n = int(reduce(lambda x, y: ''.join([str(x), str(y)]), tmp_ds, ''))
        if not is_prime(tmp_n):
            return False
    return True
Example #13
0
def problem30():
    """
    Find the sum of all the numbers that can be written as the sum of fifth
    powers of their digits.
    """
    powers = [0, 1, 32, 243, 1024, 3125, 7776, 16807, 32768, 59049]
    total, i = 0, 3
    while i < 1000000:
        num_total = 0
        for d in util.digits(i):
            num_total += powers[d]
        if num_total == i:
            total += i
        i += 1
    return total
Example #14
0
def problem56():
    """
    A googol (10100) is a massive number: one followed by one-hundred zeros;
    100100 is almost unimaginably large: one followed by two-hundred zeros.
    Despite their size, the sum of the digits in each number is only 1.

    Considering natural numbers of the form, a^b, where a, b < 100, what is
    the maximum digital sum?
    """
    r = range(1, 101)
    m = 0
    for a in r:
        for b in r:
            m = max(m, sum(util.digits(pow(a, b))))
    return m
Example #15
0
def problem52():
    """
    It can be seen that the number, 125874, and its double, 251748, contain
    exactly the same digits, but in a different order.

    Find the smallest positive integer, x, such that 2x, 3x, 4x, 5x, and 6x,
    contain the same digits.
    """
    i = 1
    while True:
        products = [i*j for j in xrange(1, 7)]
        testdigits = [sorted(util.digits(p)) for p in products]

        for test in testdigits:
            if test != testdigits[0]:
                break
        else:
            return i
        i += 1
Example #16
0
def problem34():
    """
    145 is a curious number, as 1! + 4! + 5! = 1 + 24 + 120 = 145.

    Find the sum of all numbers which are equal to the sum of the factorial
    of their digits.

    Note: as 1! = 1 and 2! = 2 are not sums they are not included.
    """
    facs = [1, 1, 2, 6, 24, 120, 720, 504, 40320, 362880]
    total, i = 0, 3
    while i < 1000000:
        num_total = 0
        for d in util.digits(i):
            num_total += facs[d]
        if num_total == i:
            total += i
        i += 1
    return total
Example #17
0
def is_pandigital(a):
    _, d = digits(a)
    return (0 not in d) and (len(set(a)) == 9)
Example #18
0
def fact_digits(x):
    return sum(factorial(i) for i in digits(x))
Example #19
0
from util import digits
from continued_fraction import convergent

answer = 0
con = convergent([1], [1, 2])
top = 1000
# ignoring the first convergent in this problem
con.next()

for i in range(top):
    n, d = con.next()
    if len(digits(n)) > len(digits(d)):
        answer += 1

print answer
Example #20
0
def problem20():
    """
    Find the sum of the digits in the number 100!
    """
    n = reduce(lambda x,y: x*y, xrange(1, 101))
    return sum(util.digits(n))
Example #21
0
def permutable(x, y):
    [num, dx] = digits(x)
    [num, dy] = digits(y)
    strx = reduce(lambda x, y: ''.join([str(x), str(y)]), sorted(dx), '')
    stry = reduce(lambda x, y: ''.join([str(x), str(y)]), sorted(dy), '')
    return strx == stry
Example #22
0
from util import digits
from continued_fraction import convergent

answer = 0
con = convergent([1], [1,2])
top = 1000
#ignoring the first convergent in this problem
con.next()

for i in range(top):    
    n, d = con.next()
    if len(digits(n)) > len(digits(d)):
        answer += 1

print answer


Example #23
0
from continued_fraction import convergent
from util import digits

def seq():
    yield 2
    k = 1
    while True:
        yield 1
        yield 2 * k
        yield 1
        k += 1


con = convergent([1], seq())
top = 100
for i in range(top):
    n,d = con.next()

print sum(digits(n))
Example #24
0
def fifth_digits(n):
    """Return the sum of the digits of n raised to the fifth power"""
    return sum(map(lambda x: x**5, digits(n)))
Example #25
0
from continued_fraction import convergent
from util import digits


def seq():
    yield 2
    k = 1
    while True:
        yield 1
        yield 2 * k
        yield 1
        k += 1


con = convergent([1], seq())
top = 100
for i in range(top):
    n, d = con.next()

print sum(digits(n))
Example #26
0
def solution():
    return sum([n for n in range(3, 50000) if (sum(map(fact, digits(n))) == n)])
Example #27
0
def fifth_digits(n):
    """Return the sum of the digits of n raised to the fifth power"""
    return sum(map(lambda x: x**5, digits(n)))
Example #28
0
from util import digits

answer = 0
for a in range(100):
    for b in range(100):
        answer = max(answer, sum(digits(a**b)))

print answer
Example #29
0
def main():
    print sum(i for i in range(3,50000) if sum(factorial(d) for d in digits(i)) == i)
Example #30
0
def is_palindrome(n):
    """Determine whether n is a palindrome."""
    d = digits(n)
    return d == d[::-1]
Example #31
0
def more_digits(x,y):
    return len(digits(x)) > len(digits(y))
Example #32
0
def solution():
    return sum(
        [n for n in range(3, 50000) if (sum(map(fact, digits(n))) == n)])
Example #33
0
def power_of_digits(n,p):
    return sum(i**p for i in digits(n))
Example #34
0
def is_palindrome(n):
    """Determine whether n is a palindrome."""
    d = digits(n)
    return d == d[::-1]