Integer to English Words - Practice Coding Problems

Integer to English Words - Problem

Transform any non-negative integer into its English words representation - just like how you would read the number aloud!

Given an integer like 123, you need to convert it to "One Hundred Twenty Three". This problem tests your ability to handle complex string manipulation, number parsing, and recursive thinking.

Key Challenge: Handle the unique patterns in English number naming - like "Eleven" vs "Ten One", "Twenty" vs "Two Ten", and the complex grouping system (thousands, millions, billions).

Examples:

123 → "One Hundred Twenty Three"
12345 → "Twelve Thousand Three Hundred Forty Five"
1234567 → "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven"

Input & Output

example_1.py — Basic Three Digits

$ Input: 123

› Output: "One Hundred Twenty Three"

💡 Note: Break down: 123 = 100 + 20 + 3. Convert to English: "One Hundred" + "Twenty" + "Three"

example_2.py — Thousands with Teens

$ Input: 12345

› Output: "Twelve Thousand Three Hundred Forty Five"

💡 Note: Groups: [12][345]. Process: "Twelve Thousand" + "Three Hundred Forty Five". Note how 12 becomes "Twelve" (not "Ten Two")

example_3.py — Edge Case Zero

$ Input: 0

› Output: "Zero"

💡 Note: Special case: the only time we return "Zero" as the complete answer

Constraints

0 ≤ num ≤ 2³¹ - 1
No leading/trailing spaces in the output
Words are separated by single spaces
No "and" conjunctions (American English style)

Visualization

Tap to expand

Understanding the Visualization

Create Lookup Tables

Build comprehensive tables for ones (0-19), tens (20-90), and scales (thousand, million, billion)

Group by Thousands

Break the number into 3-digit groups from right to left (ones, thousands, millions, etc.)

Process Each Group

Convert each 3-digit group using helper function that handles hundreds, tens, and ones

Add Scale Suffixes

Append appropriate scale words (Thousand, Million, Billion) to non-zero groups

Combine and Clean

Join all parts from largest to smallest scale with proper spacing

Key Takeaway

🎯 Key Insight: English numbers follow a systematic 3-digit grouping pattern with consistent internal rules, making lookup tables and recursive processing the optimal approach.

Asked in

G Google 42 ⊞ Microsoft 38 a Amazon 31 f Meta 24

The optimal solution uses comprehensive lookup tables for English number words and processes numbers in 3-digit groups. Key insight: English numbers follow a predictable pattern where each group (ones, thousands, millions) uses the same internal structure with different scale suffixes. This approach correctly handles all special cases like teen numbers (11-19) and produces properly formatted English text.

Common Approaches

Approach	Time	Space	Notes
✓ Systematic Grouping with Lookup Tables	O(log n)	O(1)	Use comprehensive lookup tables and process numbers in 3-digit groups

Systematic Grouping with Lookup Tables — Algorithm Steps

Create lookup tables for ones (0-19), tens (20, 30, 40...), and scales (thousand, million, billion)
Break the number into 3-digit groups from right to left
Process each group using helper function for hundreds conversion
Add appropriate scale suffix for each group
Combine all parts with proper spacing and cleanup

Visualization

Tap to expand

Step-by-Step Walkthrough

Group by 3 digits

Split 1234567 → [1] [234] [567]

Process each group

Convert using lookup tables and helper functions

Add scale suffixes

Add Million, Thousand, etc.

Combine results

Join all parts with proper spacing

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* ones[] = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine",
               "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", 
               "Seventeen", "Eighteen", "Nineteen"};

char* tens[] = {"", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};

char* thousands[] = {"", "Thousand", "Million", "Billion"};

void helper(int n, char* result) {
    if (n == 0) {
        result[0] = '\0';
        return;
    }
    
    if (n < 20) {
        strcpy(result, ones[n]);
    } else if (n < 100) {
        strcpy(result, tens[n / 10]);
        if (n % 10 != 0) {
            strcat(result, " ");
            strcat(result, ones[n % 10]);
        }
    } else {
        strcpy(result, ones[n / 100]);
        strcat(result, " Hundred");
        if (n % 100 != 0) {
            char temp[100];
            helper(n % 100, temp);
            strcat(result, " ");
            strcat(result, temp);
        }
    }
}

char* numberToWords(int num) {
    if (num == 0) {
        char* result = malloc(5);
        strcpy(result, "Zero");
        return result;
    }
    
    char* result = malloc(1000);
    result[0] = '\0';
    
    char groups[4][100];
    int groupCount = 0;
    
    while (num > 0 && groupCount < 4) {
        int group = num % 1000;
        if (group != 0) {
            helper(group, groups[groupCount]);
            if (strlen(thousands[groupCount]) > 0) {
                strcat(groups[groupCount], " ");
                strcat(groups[groupCount], thousands[groupCount]);
            }
            groupCount++;
        }
        num /= 1000;
    }
    
    // Reverse and join
    for (int i = groupCount - 1; i >= 0; i--) {
        if (strlen(result) > 0) strcat(result, " ");
        strcat(result, groups[i]);
    }
    
    return result;
}

int main() {
    int num;
    scanf("%d", &num);
    printf("%s\n", numberToWords(num));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Process number in groups of 3 digits, so time is proportional to number of digits

⚡ Linearithmic

Space Complexity

O(1)

Fixed-size lookup tables regardless of input size

✓ Linear Space

67.2K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Systematic Grouping with Lookup Tables — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler