Number to Words

Hard30 min

Prompt

Write a function numberToWords(num) that takes a non-negative integer and returns its English word form.

Copy
numberToWords(18653);
// "eighteen thousand six hundred fifty three"
numberToWords(0);
// "zero"
numberToWords(1000000);
// "one million"

The output uses lowercase words separated by single spaces. No commas, no hyphens, no "and".

Requirements

• Return the English word form of a non-negative integer
• numberToWords(0) returns "zero"
• Words are lowercase, separated by single spaces, with no "and"
• Support values up to the billions

Playground

Solution

Explanation

The problem breaks into two parts:

1. Convert any 3-digit number (0 to 999) into words.
2. Walk the input in 3-digit chunks from right to left and glue the chunks together with scale words (thousand, million, billion).

Once you see those two layers, the rest is lookup tables and a loop.

The lookup tables

English number words do not follow a single pattern. ten, eleven, twelve, and the rest of the teens are all irregular. Hardcoded tables are simpler than trying to build the words from rules.

Copy
const ONES = [
  '',
  'one',
  'two',
  'three',
  'four',
  'five',
  'six',
  'seven',
  'eight',
  'nine',
];
const TEENS = [
  'ten',
  'eleven',
  'twelve',
  'thirteen',
  'fourteen',
  'fifteen',
  'sixteen',
  'seventeen',
  'eighteen',
  'nineteen',
];
const TENS = [
  '',
  '',
  'twenty',
  'thirty',
  'forty',
  'fifty',
  'sixty',
  'seventy',
  'eighty',
  'ninety',
];
const SCALES = ['', 'thousand', 'million', 'billion'];

Two small details:

• ONES[0] is an empty string. That way ONES[digit] gives nothing for a leading zero and we can push it into the parts list without a special check.
• TENS[0] and TENS[1] are empty because the tens slot is only used for 20 through 90. Values 10 through 19 go through TEENS.

The three-digit helper

Every 3-digit number has the same shape: an optional hundreds word, an optional tens word, and an optional ones or teens word.

Copy
function threeDigit(n) {
  const parts = [];
  if (n >= 100) {
    parts.push(ONES[Math.floor(n / 100)], 'hundred');
    n %= 100;
  }
  if (n >= 20) {
    parts.push(TENS[Math.floor(n / 10)]);
    n %= 10;
  } else if (n >= 10) {
    parts.push(TEENS[n - 10]);
    n = 0;
  }
  if (n > 0) {
    parts.push(ONES[n]);
  }
  return parts.join(' ');
}

Walk through a few inputs to see how it works:

• threeDigit(653) → hundreds: six hundred, n becomes 53 → tens: fifty, n becomes 3 → ones: three. Result: "six hundred fifty three".
• threeDigit(18) → skip hundreds, fall into the n >= 10 branch → eighteen. Result: "eighteen".
• threeDigit(700) → seven hundred, then n is 0. Result: "seven hundred".
• threeDigit(15) → fifteen. Result: "fifteen".

The main loop

Now we walk the input in chunks of 1000:

Copy
function numberToWords(num) {
  if (num === 0) return 'zero';
  const chunks = [];
  let scaleIndex = 0;
  while (num > 0) {
    const chunk = num % 1000;
    if (chunk > 0) {
      const words = threeDigit(chunk);
      const scale = SCALES[scaleIndex];
      chunks.unshift(scale ? `${words} ${scale}` : words);
    }
    num = Math.floor(num / 1000);
    scaleIndex++;
  }
  return chunks.join(' ');
}

num % 1000 pulls out the lowest three digits, Math.floor(num / 1000) drops them. Each iteration produces one chunk and scaleIndex tells us which scale word to attach. The lowest chunk has no scale (SCALES[0] is an empty string), the next one is thousand, then million, then billion.

Because we process the lowest chunk first, we use unshift to put the newest chunk at the front of the list.

Trace for 18653:

1. chunk = 653, scale "" → threeDigit(653) is "six hundred fifty three" → chunks: ["six hundred fifty three"].
2. chunk = 18, scale "thousand" → threeDigit(18) is "eighteen" → chunks: ["eighteen thousand", "six hundred fifty three"].
3. num is now 0, loop ends.

Join the list: "eighteen thousand six hundred fifty three".

Why the zero case is handled up front

If num is 0, the loop condition num > 0 is false on the first check and the loop never runs. The function would return an empty string. The early return fixes that.

Small extensions

• Negatives. Add one line at the top:

  Copy
  if (num < 0) return 'negative ' + numberToWords(-num);

• Trillions and beyond. Extend SCALES:

  Copy
  const SCALES = [
    '',
    'thousand',
    'million',
    'billion',
    'trillion',
  ];

  The loop does not change.