# digit seperator
def get_digit(num, place):
    return (num % (10**(place+1))) - (num % (10**place))

# convert numbers between 0 and 1000 to English (used in get_eng_num)
def get_eng_num_under_1000(num):
    # separate digits
    digits = [get_digit(num, place)/(10**place) for place in range(len(str(num)))]
    digits.reverse()

    # create number to English mappings
    singles = {1:"one", 2:"two", 3:"three", 4:"four", 5:"five", 6:"six", 7:"seven", 8:"eight", 9:"nine"}
    powers_of_ten = {10:"ten", 100:"hundred"}

    # create improper English to proper English mappings
    tens_convert = {2:"twenty", 3:"thirty", 4:"forty", 5:"fifty", 6:"sixty", 7:"seventy", 8:"eighty", 9:"ninety"}
    teens_convert = {1: "eleven", 2:"twelve", 3:"thirteen", 4:"fourteen", 5:"fifteen",
                    6:"sixteen", 7:"seventeen", 8:"eighteen", 9:"nineteen"}

    # convert numbers to English
    english_number = []
    size = len(digits)
    # if the number in in the hundreds
    if size == 3:
        # convert hundreds
        if digits[-3] > 0:
            english_number.append(" ".join([singles[digits[0]], "hundred"]))
    # if the number is in the hundreds or tens
    if size >= 2:
        # convert tens, except teens
        if digits[-2] > 1:
            english_number.append(tens_convert[digits[-2]])
            # convert ones
            if digits[-1] > 0:
                english_number.append(singles[digits[-1]])
        # convert teens (except ten)
        elif digits[-2] == 1 and digits[-1] > 0:
            english_number.append(teens_convert[digits[-1]])
        # convert ten
        elif digits[-2] == 1 and digits[-1] == 0:
            english_number.append("ten")
        # convert less than ten
        elif digits[-2] == 0 and digits[-1] > 0:
            english_number.append(singles[digits[-1]])
    # if the number is a single digit
    if len(digits) == 1:
        # convert ones
        if digits[-1] > 0:
            english_number.append(singles[digits[-1]])

    # join and return English number
    return " ".join(english_number)

# convert a number to it's English equivalent
def get_eng_num(num):
    # separate digits, and return only the digit (not the full digit value)
    digits = [int(get_digit(num, place)/(10**place)) for place in range(len(str(num)))]

    # how many groups of three we can make:
    size = round((len(digits) + 1)/3)
    # separate into groups of three
    threes = []
    for i in range(size):
        new_three = [str(d) for d in digits[(3*i):(3*i)+3]]
        new_three.reverse()
        threes.append(int("".join(new_three)))

    # convert each group of three to English and add on appropriate power of 1000
    powers_of_1000 = ["", "thousand", "million", "billion", "trillion", "quadrillion", "quintillion",
                    "sextillion", "septillion", "octillion", "nonillion", "decillion"]
    english_number = []
    for i, three in enumerate(threes):
        if three:
            if i == 0:
                english_number.append(get_eng_num_under_1000(three))
            else:
                english_number.append(" ".join([get_eng_num_under_1000(three), powers_of_1000[i]]))

    # reverse and join it all together, or return "zero" if there's nothing left
    english_number.reverse()
    if english_number:
        return " ".join(english_number)
    else:
        return "zero"

# main function for the "word product"
def compute_word_product(num):
    words = get_eng_num(num).split(" ")
    word_product = 1
    # also returns length of each word for printing later
    word_lengths = []
    for word in words:
        word_product *= len(word)
        word_lengths.append(str(len(word)))

    return word_product, word_lengths

# value to be set \/
for n in range(2000000):
    n_word_product, n_word_lengths = compute_word_product(n)
    if n_word_product == n:
        print(f"{n} -> {get_eng_num(n)} ({' * '.join(n_word_lengths)})")