LeetCode 273: Integer to English Words Solution in Python – A Step-by-Step Guide

What Is LeetCode 273: Integer to English Words?

In LeetCode 273: Integer to English Words, you’re given a non-negative integer num, and your task is to return its English word representation as a string, using proper spacing and capitalization (e.g., "One Hundred" not "onehundred"). For example, 123 becomes "One Hundred Twenty Three," and 1,234,567 becomes "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven." This problem tests string manipulation and number parsing, related to challenges like LeetCode 12: Integer to Roman, but focuses on English words instead of symbols.

Problem Statement

• Input: A non-negative integer num.
• Output: A string—the English word representation of num.
• Rules: Use spaces between words; capitalize first letters; handle 0 to 2^31 - 1; no leading "and" or hyphens.

Constraints

• num: 0 to 2^31 - 1 (max 32-bit integer).

Examples

• Input: num = 123
• Output: "One Hundred Twenty Three"
• Input: num = 12345
• Output: "Twelve Thousand Three Hundred Forty Five"
• Input: num = 0
• Output: "Zero"
• Input: num = 1000000
• Output: "One Million"

Understanding the Problem: Turning Numbers into Words

To solve LeetCode 273: Integer to English Words in Python, we need to convert an integer into its English word form, breaking it into parts (billions, millions, thousands, ones) and spelling each part correctly. For 12345, we split into 12 (thousands) and 345 (ones), then say "Twelve Thousand Three Hundred Forty Five." A basic way—building digit-by-digit—works but gets messy with larger numbers. We’ll use two methods: 1. Best Solution (Divide-and-Conquer with Word Mapping): O(log n) time—fast and clear. 2. Alternative Solution (Iterative Digit Processing): O(log n)—step-by-step but manual.

Let’s dive into the best solution with a friendly, detailed walkthrough.

Best Solution: Divide-and-Conquer with Word Mapping

Why This Is the Best Solution

The divide-and-conquer with word mapping approach is the top pick for LeetCode 273 because it runs in O(log n) time—where n is the input number—and breaks the problem into manageable chunks (billions, millions, etc.), using pre-set word lists for clarity and speed. It’s like chopping a big number into bite-sized pieces and dressing each with the right words, making it both efficient and easy to follow once you see it in action.

How It Works

Picture this solution as slicing a giant number cake into layers—billions, millions, thousands, and ones—then decorating each layer with English words using a handy cheat sheet. You process each chunk (up to 999) the same way, adding the right suffix (e.g., "Thousand"). Here’s how it works, step-by-step, explained simply:

• Step 1: Set Up Word Maps:
• Create lists for ones (1-19), tens (20-90), and big units (Thousand, Million, Billion).
• Step 2: Handle Zero:
• If num = 0, return "Zero" directly.
• Step 3: Break into Chunks:
• Divide num by 10^9 (billions), 10^6 (millions), 10^3 (thousands), and take remainders.
• Process each chunk (0-999) separately.
• Step 4: Convert Chunks to Words:
• For each chunk (e.g., 345):
• Hundreds: If ≥ 100, say the hundred part (e.g., 3 → "Three Hundred").
• Tens: Take remainder % 100, if 20-99, use tens (e.g., 40 → "Forty").
• Ones: If < 20, use ones list (e.g., 15 → "Fifteen").
• Add suffix if chunk isn’t from ones (e.g., "Thousand").
• Step 5: Join and Clean:
• Combine all parts with spaces, trim extras.

It’s like assembling a word sandwich—slice, layer, and season each part!

Step-by-Step Example

Example: num = 12345

• Step 1: Word maps:
• Ones: ["", "One", "Two", ..., "Nineteen"].
• Tens: ["", "", "Twenty", "Thirty", ..., "Ninety"].
• Units: ["", "Thousand", "Million", "Billion"].
• Step 2: num ≠ 0.
• Step 3: Break into chunks:
• Billions: 12345 // 10^9 = 0.
• Millions: 12345 // 10^6 = 0.
• Thousands: 12345 // 10^3 = 12, remainder = 345.
• Ones: 345.
• Step 4: Convert chunks:
• 12 (thousands):
• < 20: "Twelve" (ones[12]).
• Suffix: "Thousand".
• "Twelve Thousand".
• 345 (ones):
• Hundreds: 345 // 100 = 3, "Three Hundred".
• Remainder: 345 % 100 = 45.
• Tens: 45 // 10 = 4, "Forty" (tens[4]).
• Ones: 45 % 10 = 5, "Five" (ones[5]).
• "Three Hundred Forty Five".
• Step 5: Join: "Twelve Thousand Three Hundred Forty Five".
• Result: "Twelve Thousand Three Hundred Forty Five".

Code with Detailed Line-by-Line Explanation

Here’s the Python code, explained in a friendly way:

Copy codeclass Solution:
    def numberToWords(self, num: int) -> str:
        # Step 1: Word mappings
        ones = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", 
                "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", 
                "Seventeen", "Eighteen", "Nineteen"]
        tens = ["", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"]
        units = ["", "Thousand", "Million", "Billion"]

        # Step 2: Handle zero
        if num == 0:
            return "Zero"

        # Step 3: Helper to convert chunks (0-999)
        def convert_chunk(n):
            words = []
            if n >= 100:
                words.append(ones[n // 100] + " Hundred")
                n %= 100
            if n >= 20:
                words.append(tens[n // 10])
                n %= 10
            if n > 0:
                words.append(ones[n])
            return " ".join(words)

        # Step 4: Process number by chunks
        result = []
        unit_idx = 0
        while num > 0:
            chunk = num % 1000
            if chunk > 0:
                chunk_words = convert_chunk(chunk)
                if unit_idx > 0:
                    chunk_words += " " + units[unit_idx]
                result.append(chunk_words)
            num //= 1000
            unit_idx += 1

        # Step 5: Join and return
        return " ".join(result[::-1])

• Line 3-9: Define word lists for ones (1-19), tens (20-90), units (Thousand+).
• Line 11-12: If num = 0, return "Zero".
• Line 14-23: Helper convert_chunk for 0-999:
• Hundreds: Add hundred part if ≥ 100.
• Tens: Add tens part if 20-99.
• Ones: Add ones part if 1-19.
• Line 25-35: Process num:
• Take chunks of 1000 (modulo).
• Convert non-zero chunks, add unit suffix.
• Shift num by 1000, increase unit index.
• Line 37: Join chunks in reverse (biggest first).

• Time Complexity: O(log n)—processes digits in groups of 3.
• Space Complexity: O(1)—fixed word lists, small result.

This solution is like a number chef—slice, season, and serve!

Alternative Solution: Iterative Digit Processing

Why an Alternative Approach?

The iterative digit processing method builds the string digit-by-digit from right to left, like reading a number aloud step-by-step. It’s O(log n) too but more manual, offering a hands-on way to see the conversion process before streamlining with chunks.

How It Works

Think of this as spelling out a number as you count its digits: start from the right, say each place (ones, tens, hundreds), and adjust for scale (thousands, millions). Here’s how it works, step-by-step:

• Step 1: Convert to string, process right to left.
• Step 2: Map digits to words, track place value.
• Step 3: Add scale words at intervals (every 3 digits).

Step-by-Step Example

Example: num = 12345

• Step 1: String = "12345".
• Step 2: Right to left:
• 5: "Five".
• 4: "Forty" (tens).
• 3: "Three Hundred".
• 2: "Two" (thousands).
• 1: "One" (ten-thousands).
• Step 3: Add scale:
• "Five" (ones), "Forty" (tens), "Three Hundred" (hundreds).
• "Two Thousand" (thousands), "One" → "Twelve Thousand".
• Result: "Twelve Thousand Three Hundred Forty Five".

Code for Iterative Approach

Copy codeclass Solution:
    def numberToWords(self, num: int) -> str:
        ones = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", 
                "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", 
                "Seventeen", "Eighteen", "Nineteen"]
        tens = ["", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"]
        units = ["", "Thousand", "Million", "Billion"]

        if num == 0:
            return "Zero"

        s = str(num)
        result = []
        place = 0

        i = len(s) - 1
        while i >= 0:
            chunk = []
            if place % 3 == 0 and i >= 0:  # Ones
                chunk.append(ones[int(s[i])])
                i -= 1
            if i >= 0 and place % 3 == 1:  # Tens
                n = int(s[i])
                if n > 1:
                    chunk.append(tens[n])
                    i -= 1
                    if i >= 0:
                        chunk.append(ones[int(s[i])])
                        i -= 1
                else:
                    i -= 1
                    if i >= 0:
                        chunk.append(ones[int(s[i+1:i-1:-1][::-1])])
                        i -= 1
            if i >= 0 and place % 3 == 2:  # Hundreds
                chunk.append(ones[int(s[i])] + " Hundred")
                i -= 1

            chunk_str = " ".join(chunk).strip()
            if chunk_str and place // 3 > 0:
                chunk_str += " " + units[place // 3]
            if chunk_str:
                result.append(chunk_str)
            place += 1

        return " ".join(result[::-1])

• Time Complexity: O(log n)—processes digits.
• Space Complexity: O(log n)—result list.

It’s a manual count but works.

Comparing the Two Solutions

• Best Solution (Divide-and-Conquer):
• Pros: O(log n) time, O(1) space, clean chunks.
• Cons: Chunk logic to learn.
• Alternative Solution (Iterative):
• Pros: O(log n) time, step-by-step view.
• Cons: O(log n) space, more complex handling.

Divide-and-conquer wins for clarity.

Additional Examples and Edge Cases

Zero

• 0 → "Zero"

Single Digit

• 5 → "Five"

Big Number

• 1234567 → "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"

Both handle these well.

Complexity Breakdown

• Divide-and-Conquer:
• Time: O(log n)—chunk processing.
• Space: O(1)—fixed space.
• Iterative:
• Time: O(log n)—digit processing.
• Space: O(log n)—result.

Divide-and-conquer is leaner.

Key Takeaways

• Divide-and-Conquer: Chunk and conquer.
• Iterative: Digit-by-digit build.
• Words: Map numbers to strings.
• Python Tip: Lists make words easy—see [Python Basics](/python/basics).

Final Thoughts: Spell Numbers Like a Pro

LeetCode 273: Integer to English Words in Python is a fun number-to-word adventure. The divide-and-conquer solution slices efficiently, while iterative spells it out step-by-step. Want more? Try LeetCode 12: Integer to Roman or LeetCode 13: Roman to Integer. Ready to convert? Head to Solve LeetCode 273 on LeetCode and turn numbers into words today!