Integer to English Words

Intuitionwhy three-digit groups make the naming rules manageable

English number names repeat the same rules every three digits. A group such as 567 is always written as Five Hundred Sixty Seven, whether it appears alone, after Thousand, or after Million. The group changes its scale word, but its internal spelling never changes.

Separate the number into groups from right to left: units, thousands, millions, and billions. Translate each nonzero group with a helper for values below 1000, then place its scale word after it. Processing from the smallest group upward means each new group can be placed before the text already built.

Approach

1. 1Return Zero immediately when the input is zero, because no three-digit group would otherwise add a word to the result.
2. 2Store the words below 20 and the multiples of ten in lookup arrays, because these are the only irregular names needed inside a group.
3. 3Write a helper for a value below 1000. Add the hundreds word when the value reaches 100, then handle the remaining tens and ones; each branch reduces the value before the next branch so no part is named twice.
4. 4Repeatedly take num % 1000 as the current group and divide num by 1000 to move to the next scale, because every division removes exactly one three-digit group.
5. 5When a group is nonzero, translate it and prepend its matching scale word, because zero groups such as the thousands group in 1,000,010 must not produce a stray Thousand.
6. 6Trim the final trailing space and return the phrase, because the helper deliberately appends spaces after emitted words to keep concatenation simple.

Complexitythe stated integer range keeps the number of groups fixed

Annotated solutionC++ · iterative group scan with a below-1000 helper

#include <string>
#include <vector>
using namespace std;

class Solution {
public:
    string numberToWords(int num) {
        if (num == 0) return "Zero";

        vector<string> thousands = {"", "Thousand", "Million", "Billion"};
        string result;
        int scale = 0;

        while (num > 0) {
            int group = num % 1000;
            if (group != 0) {
                result = helper(group) + thousands[scale] + " " + result;
            }
            num /= 1000;
            scale++;
        }

        while (result.back() == ' ') result.pop_back();
        return result;
    }

private:
    string helper(int num) {
        vector<string> below20 = {
            "", "One", "Two", "Three", "Four", "Five", "Six", "Seven",
            "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen",
            "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen",
            "Nineteen"
        };
        vector<string> tens = {
            "", "", "Twenty", "Thirty", "Forty", "Fifty",
            "Sixty", "Seventy", "Eighty", "Ninety"
        };

        string result;

        if (num >= 100) {
            result += below20[num / 100] + " Hundred ";
            num %= 100;
        }
        if (num >= 20) {
            result += tens[num / 10] + " ";
            num %= 10;
        }
        if (num > 0) {
            result += below20[num] + " ";
        }

        return result;
    }
};

The order of the two divisions is important. The remainder extracts the group that belongs to the current scale, while division advances to the next group. Because this scan discovers units before thousands and millions, the newly translated text is placed before result. A zero group is skipped entirely; its position is already represented by the next scale index.

Common mistakesthe two gaps that produce convincing but incorrect phrases