Integer to English Words

Convert a non-negative integer to its English words representation by processing groups of three digits

Number Groups

Helper Decomposition

Click Step or Play to begin

BELOW_TWENTY

TENS

Result

Input

Current Scale

Group Value

Groups Left

Click "Step" or "Play" to start the visualization

Ones

Thousands

Millions

Billions

Python Code

                def numberToWords(num):
            
                    if num == 0: return "Zero"
            
                    res = ""; i = 0
            
                    while num > 0:
            
                        group = num % 1000
            
                        if group != 0:
            
                            res = helper(group) + SCALE[i] + res
            
                        num //= 1000; i += 1
            
                def helper(n):
            
                    if n < 20: return BELOW_20[n]
            
                    if n < 100: return TENS[n//10] + helper(n%10)
            
                    return BELOW_20[n//100] + "Hundred" + helper(n%100)
            
                    return res.strip()

Complexity Analysis

Time Complexity O(1) Space Complexity O(1)

Time Complexity: O(1)

Breakdown

Input is bounded: 0 ≤ num ≤ 2³¹ − 1 (at most 10 digits)
At most 4 groups of 3 digits (billions, millions, thousands, ones)
Each group requires at most 3 recursive helper calls (hundreds, tens, ones)
All lookups into BELOW_TWENTY and TENS are O(1) array access

T = 4 groups × 3 helper calls = 12 operations max = O(1)

Key Insight

Because the input is a 32-bit integer, the number of groups and helper calls is bounded by a constant. The algorithm does not scale with input size — it always performs a fixed number of operations regardless of the specific number.

Space Complexity: O(1)

Breakdown

Lookup tables (BELOW_TWENTY, TENS, SCALE) are fixed-size constants
Recursion depth in helper: at most 3 levels (hundreds → tens → ones)
Output string length is bounded (longest: "Two Billion..." ~40 chars)

S = O(1) — all storage is bounded by constants

Key Insight

The helper function recurses at most 3 levels deep for any 3-digit number. Combined with fixed-size lookup tables, the total memory usage is constant regardless of the input value.