Integer To English Words

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

        String[] lessThan20 = {"", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten",
                "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"};
        String[] tens = {"", "Ten", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"};
        String[] thousands = {"", "Thousand", "Million", "Billion"};

        int i = 0;
        String words = "";

        while (num > 0) {
            if (num % 1000 != 0) {
                words = helper(num % 1000, lessThan20, tens) + thousands[i] + " " + words;
            }
            num /= 1000;
            i++;
        }

        return words.trim();
    }

    private String helper(int num, String[] lessThan20, String[] tens) {
        if (num == 0) {
            return "";
        } else if (num < 20) {
            return lessThan20[num] + " ";
        } else if (num < 100) {
            return tens[num / 10] + " " + helper(num % 10, lessThan20, tens);
        } else {
            return lessThan20[num / 100] + " Hundred " + helper(num % 100, lessThan20, tens);
        }
    }
}

                                            
class Solution(object):
    def numberToWords(self, num):
        """
        :type num: int
        :rtype: str
        """
        if num == 0:
            return "Zero"
        
        LESS_THAN_20 = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten",
                        "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"]
        
        TENS = ["", "Ten", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"]
        
        THOUSANDS = ["", "Thousand", "Million", "Billion"]
        
        def helper(n):
            if n == 0:
                return ""
            elif n < 20:
                return LESS_THAN_20[n] + " "
            elif n < 100:
                return TENS[n // 10] + " " + helper(n % 10)
            else:
                return LESS_THAN_20[n // 100] + " Hundred " + helper(n % 100)
        
        res = ""
        i = 0
        while num > 0:
            if num % 1000 != 0:
                res = helper(num % 1000) + THOUSANDS[i] + " " + res
            num //= 1000
            i += 1
        
        return res.strip()

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

        string[] belowTen = new string[] { "", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine" };
        string[] belowTwenty = new string[] { "", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen" };
        string[] belowHundred = new string[] { "", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety" };
        
        string[] units = new string[] { "", "Thousand", "Million", "Billion" };

        int i = 0;
        string words = "";

        while (num > 0)
        {
            if (num % 1000 != 0)
            {
                words = Helper(num % 1000, belowTen, belowTwenty, belowHundred) + units[i] + " " + words;
            }
            num /= 1000;
            i++;
        }

        return words.Trim();
    }

    private string Helper(int num, string[] belowTen, string[] belowTwenty, string[] belowHundred)
    {
        if (num == 0)
        {
            return "";
        }
        else if (num < 10)
        {
            return belowTen[num] + " ";
        }
        else if (num < 20)
        {
            return belowTwenty[num] + " ";
        }
        else if (num < 100)
        {
            return belowHundred[num / 10] + " " + Helper(num % 10, belowTen, belowTwenty, belowHundred);
        }
        else
        {
            return belowTen[num / 100] + " Hundred " + Helper(num % 100, belowTen, belowTwenty, belowHundred);
        }
    }
}

                                            
/**
 * @param {number} num
 * @return {string}
 */
var numberToWords = function(num) {
    if (num === 0) return "Zero";
    const lessThan20 = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"];
    const tens = ["", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"];
    const thousands = ["", "Thousand", "Million", "Billion"];
    
    const toWords = (num) => {
        if (num === 0) return "";
        if (num < 20) return lessThan20[num];
        if (num < 100) return tens[Math.floor(num/10)] + (num % 10 !== 0 ? " " + lessThan20[num % 10] : "");
        return lessThan20[Math.floor(num/100)] + " Hundred" + (num % 100 !== 0 ? " " + toWords(num % 100) : "");
    };
    
    let word = "", level = 0;
    while (num > 0) {
        const part = num % 1000;
        if (part !== 0) {
            word = toWords(part) + " " + thousands[level] + " " + word;
        }
        level++;
        num = Math.floor(num / 1000);
    }
    
    return word.trim();
};

                                            
function numberToWords(num: number): string {
    if (num === 0) return "Zero";

    const under20 = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten",
        "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"];
    const tens = ["", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"];
    const thousands = ["", "Thousand", "Million", "Billion"];

    const getString = (num: number): string => {
        if (num === 0) return "";
        else if (num < 20) return under20[num] + " ";
        else if (num < 100) return tens[Math.floor(num / 10)] + " " + getString(num % 10);
        else return under20[Math.floor(num / 100)] + " Hundred " + getString(num % 100);
    };

    let result = "";
    let i = 0;

    while (num > 0) {
        if (num % 1000 !== 0) {
            result = getString(num % 1000) + thousands[i] + " " + result;
        }
        num = Math.floor(num / 1000);
        i++;
    }

    return result.trim();
};

                                            
class Solution {
    func numberToWords(_ num: Int) -> String {
        if num == 0 {
            return "Zero"
        }
        
        let belowTwenty = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten",
                           "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"]
        let tens = ["", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"]
        let thousands = ["", "Thousand", "Million", "Billion"]
        
        func helper(_ n: Int) -> String {
            if n == 0 {
                return ""
            } else if n < 20 {
                return belowTwenty[n] + " "
            } else if n < 100 {
                return tens[n / 10] + " " + helper(n % 10)
            } else {
                return belowTwenty[n / 100] + " Hundred " + helper(n % 100)
            }
        }
        
        var res = ""
        var i = 0
        var number = num
        
        while number > 0 {
            if number % 1000 != 0 {
                res = helper(number % 1000) + thousands[i] + " " + res
            }
            number /= 1000
            i += 1
        }
        
        return res.trimmingCharacters(in: .whitespaces)
    }
}

                                            
class Solution {
  String numberToWords(int num) {
    if (num == 0) return "Zero";
    return helper(num);
  }

  String helper(int num) {
    List<String> belowTwenty = [
      "", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight",
      "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen",
      "Sixteen", "Seventeen", "Eighteen", "Nineteen"
    ];

    List<String> tens = [
      "", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy",
      "Eighty", "Ninety"
    ];

    if (num < 20) {
      return belowTwenty[num];
    } else if (num < 100) {
      return tens[num ~/ 10] + (num % 10 == 0 ? "" : " " + helper(num % 10));
    } else if (num < 1000) {
      return belowTwenty[num ~/ 100] + " Hundred" +
          (num % 100 == 0 ? "" : " " + helper(num % 100));
    } else if (num < 1000000) {
      return helper(num ~/ 1000) + " Thousand" + 
          (num % 1000 == 0 ? "" : " " + helper(num % 1000));
    } else if (num < 1000000000) {
      return helper(num ~/ 1000000) + " Million" + 
          (num % 1000000 == 0 ? "" : " " + helper(num % 1000000));
    } else {
      return helper(num ~/ 1000000000) + " Billion" + 
          (num % 1000000000 == 0 ? "" : " " + helper(num % 1000000000));
    }
  }
}

                                            
# @param {Integer} num
# @return {String}
def number_to_words(num)
    if num == 0
        return "Zero"
    end

    less_than_20 = ["", "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"]
    thousands = ["", "Thousand", "Million", "Billion"]

    i = 0
    words = ""
    
    while num > 0
        if (num % 1000) != 0
            words = helper(num % 1000, less_than_20, tens) + thousands[i] + " " + words
        end
        num = num / 1000
        i += 1
    end

    return words.strip
end

def helper(num, less_than_20, tens)
    if num == 0
        return ""
    elsif num < 20
        return less_than_20[num] + " "
    elsif num < 100
        return tens[num/10] + " " + helper(num % 10, less_than_20, tens)
    else
        return less_than_20[num/100] + " Hundred " + helper(num % 100, less_than_20, tens)
    end
end

                                            
impl Solution {
    pub fn number_to_words(num: i32) -> String {
        if num == 0 {
            return String::from("Zero");
        }

        let less_than_20 = vec![
            "", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten",
            "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen",
            "Eighteen", "Nineteen",
        ];

        let tens = vec![
            "", "", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety",
        ];

        let thousands = vec!["", "Thousand", "Million", "Billion"];

        fn helper(num: i32, less_than_20: &Vec<&str>, tens: &Vec<&str>, thousands: &Vec<&str>) -> String {
            if num == 0 {
                return String::new();
            } else if num < 20 {
                return less_than_20[num as usize].to_string() + " ";
            } else if num < 100 {
                return tens[(num / 10) as usize].to_string() + " " + &helper(num % 10, less_than_20, tens, thousands);
            } else {
                return less_than_20[(num / 100) as usize].to_string()
                    + " Hundred "
                    + &helper(num % 100, less_than_20, tens, thousands);
            }
        }

        let mut result = String::new();
        let mut i = 0;
        let mut num = num;

        while num > 0 {
            if num % 1000 != 0 {
                result = helper(num % 1000, &less_than_20, &tens, &thousands) + thousands[i] + " " + &result;
            }
            num /= 1000;
            i += 1;
        }

        result.trim().to_string()
    }
}

To solve this coding challenge of converting a non-negative integer to its English words representation, we can divide the solution into several manageable parts. Here's a detailed breakdown of the approach:

Explanation

The first step is to handle the edge case where the number is zero. For this, we can simply return "Zero". Next, we need to devise a way to handle numbers by breaking them down and processing them in chunks of thousands (e.g., thousand, million, billion). We need mappings for the following:

Numbers less than twenty.
Tens multiples.
Thousands, millions, and billions.

For the numbers less than twenty and the tens, we create lists, as these are direct mappings. The "thousands" list helps append the correct thousand, million, or billion label while we iterate through the number.

The core of the solution involves a helper function that recursively converts numbers less than a thousand to words. For the main logic, as we process each chunk of the number (from the least significant to the most significant part), we invoke this helper function and append the appropriate thousand label.

Here's the pseudocode explaining how to solve it step-by-step:

Initial Setup

Define a function that takes in the number.
If the number is zero, return "Zero".
Create lists for:

Numbers less than 20.
Tens multiples.
Thousands (including empty string for units).

Helper Function

Define a helper function that takes a number less than 1000 and converts it to words:

If the number is zero, return an empty string.
If the number is less than 20, use the less than 20 list.
If the number is less than 100, process the tens and the remainder recursively.
Otherwise, process the hundreds place and the remainder recursively.

Main Logic

Initialize an empty result string and a variable for indexing the thousands list.
While the number is greater than zero:

Process the last three digits of the number using the helper function.
Append the appropriate thousand label if the chunk is not zero.
Move to the next chunk by dividing the number by 1000.
Increment the thousands index.

Return the result string after trimming.

Detailed Steps in Pseudocode:

                                            
function numberToWords(num):
  # List for numbers less than 20
  LESS_THAN_20 = ["", "One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten", "Eleven", "Twelve", "Thirteen", "Fourteen", "Fifteen", "Sixteen", "Seventeen", "Eighteen", "Nineteen"]
  
  # List for tens multiples
  TENS = ["", "Ten", "Twenty", "Thirty", "Forty", "Fifty", "Sixty", "Seventy", "Eighty", "Ninety"]
  
  # List for thousands, millions, billions
  THOUSANDS = ["", "Thousand", "Million", "Billion"]
  
  # Function to handle numbers less than 1000
  function helper(n):
    if n == 0:
      return ""
    elseif n < 20:
      return LESS_THAN_20[n] + " "
    elseif n < 100:
      return TENS[n // 10] + " " + helper(n % 10)
    else:
      return LESS_THAN_20[n // 100] + " Hundred " + helper(n % 100)

  # Edge case for zero
  if num == 0:
    return "Zero"
  
  # Initialize result string and index for thousands list
  result = ""
  i = 0

  # Process each chunk of the number
  while num > 0:
    if num % 1000 != 0:
      result = helper(num % 1000) + THOUSANDS[i] + " " + result
    num = num // 1000
    i += 1
  
  # Return the result string after removing any extra spaces
  return result.strip()

In summary, the solution involves breaking down the problem into manageable components, processing each chunk of the number iteratively, and using recursion to convert smaller numbers to words. By using lists for different ranges of numbers, we simplify the mapping process and ensure efficient conversion from integer parts to their respective word forms.