Integer to English Words

Integer to English Words is a classic "annoying but easy" interview problem. There is no clever algorithm — the whole challenge is organizing the work so the special cases (teens, zeros, scale words) do not turn into spaghetti. The trick is to break the number into groups of three digits.

The slow way first

You could try to handle the whole number with one giant chain of if statements — "if it is in the millions, then... if the millions part has a hundreds digit, then...". That works for one example and collapses the moment you hit a number shaped differently. Every case (teens like 13, round numbers like 100, embedded zeros like 1000007) becomes a new branch. It is unmaintainable and easy to get wrong.

The question to ask: what is the smallest piece I actually know how to spell? The answer is a three-digit chunk (0–999). If I can spell any number under 1000, I can spell any number at all.

The idea: split into thousand-groups

Western number-reading already groups digits in threes: 1,234,567. So split the number into groups of three digits from the right. Each group has a fixed scale word: from the right, the groups are ones, Thousand, Million, Billion. Convert each 3-digit group to words with one small helper, then tack on its scale word.

The 3-digit helper itself is tiny: an optional "X Hundred" from the hundreds digit, then the remaining two digits (which need their own small lookup for teens and tens).

Walk through it

Step through the animation. The group pointer moves across the three chunks 1 | 234 | 567. For each chunk we spell the three digits, then append the scale word printed beneath it (Million, Thousand, none). The words string at the bottom grows until it holds the full phrase.

Pseudocode

if num is 0: return "Zero"
split num into 3-digit groups, most-significant first   # [1, 234, 567]
line up scale words from the right: ..., Million, Thousand, ones
words = ""
for each (chunk, scale) in groups:
    if chunk is 0: skip it
    spell hundreds digit -> "X Hundred" (if nonzero)
    spell the last two digits (teens / tens + ones)
    if scale is not the ones group: append the scale word
return words trimmed

The Python solution

def number_to_words(num):
    if num == 0:
        return "Zero"
    groups = chunk_into_thousands(num)   # e.g. [1, 234, 567]
    scales = ["Billion", "Million", "Thousand", ""]
    scales = scales[len(scales) - len(groups):]
    words = ""
    for chunk, scale in zip(groups, scales):
        if chunk == 0:
            continue
        h, rest = divmod(chunk, 100)
        if h:
            words += " " + ONES[h] + " Hundred"
        words += " " + two_digits(rest)   # tens + ones
        if scale:
            words += " " + scale
    return words.strip()

• chunk_into_thousands slices the number into 3-digit groups, most-significant first.
• scales is sliced so the last group lines up with "" (ones, no scale word) and each earlier group gets Thousand / Million / Billion.
• if chunk == 0: continue skips empty groups, so 1000007 does not print "Zero Thousand".
• divmod(chunk, 100) splits a chunk into its hundreds digit h and the remaining two digits rest.
• two_digits(rest) handles the only real special case — teens (13 is "Thirteen", not "Tenty Three") and the tens words.
• We strip() at the end because every piece was added with a leading space.

Complexity

Because a 32-bit integer has at most four thousand-groups, this is effectively constant time — the value is bounded. The "complexity" here is purely about clean code, not Big-O.

When this pattern shows up

Practice