Move and reimplement convert_number_to_words.py (TheAlgorithms#8998)

* Move and reimplement convert_number_to_words.py

- Move convert_number_to_words.py from web_programming/ to conversions/
- Reimplement the algorithm from scratch because the logic was very
  opaque and too heavily nested
- Add support for the Western numbering system (both short and long)
  because the original implementation only supported the Indian
  numbering system
- Add extensive doctests and error handling

* updating DIRECTORY.md

---------

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>

Author: tianyizheng02

DIRECTORY.md

@@ -143,6 +143,7 @@
   * [Binary To Decimal](conversions/binary_to_decimal.py)
   * [Binary To Hexadecimal](conversions/binary_to_hexadecimal.py)
   * [Binary To Octal](conversions/binary_to_octal.py)
+  * [Convert Number To Words](conversions/convert_number_to_words.py)
   * [Decimal To Any](conversions/decimal_to_any.py)
   * [Decimal To Binary](conversions/decimal_to_binary.py)
   * [Decimal To Binary Recursion](conversions/decimal_to_binary_recursion.py)
@@ -1203,7 +1204,6 @@
 
 ## Web Programming
   * [Co2 Emission](web_programming/co2_emission.py)
-  * [Convert Number To Words](web_programming/convert_number_to_words.py)
   * [Covid Stats Via Xpath](web_programming/covid_stats_via_xpath.py)
   * [Crawl Google Results](web_programming/crawl_google_results.py)
   * [Crawl Google Scholar Citation](web_programming/crawl_google_scholar_citation.py)

conversions/convert_number_to_words.py

@@ -0,0 +1,205 @@
+from enum import Enum
+from typing import ClassVar, Literal
+
+
+class NumberingSystem(Enum):
+    SHORT = (
+        (15, "quadrillion"),
+        (12, "trillion"),
+        (9, "billion"),
+        (6, "million"),
+        (3, "thousand"),
+        (2, "hundred"),
+    )
+
+    LONG = (
+        (15, "billiard"),
+        (9, "milliard"),
+        (6, "million"),
+        (3, "thousand"),
+        (2, "hundred"),
+    )
+
+    INDIAN = (
+        (14, "crore crore"),
+        (12, "lakh crore"),
+        (7, "crore"),
+        (5, "lakh"),
+        (3, "thousand"),
+        (2, "hundred"),
+    )
+
+    @classmethod
+    def max_value(cls, system: str) -> int:
+        """
+        Gets the max value supported by the given number system.
+
+        >>> NumberingSystem.max_value("short") == 10**18 - 1
+        True
+        >>> NumberingSystem.max_value("long") == 10**21 - 1
+        True
+        >>> NumberingSystem.max_value("indian") == 10**19 - 1
+        True
+        """
+        match (system_enum := cls[system.upper()]):
+            case cls.SHORT:
+                max_exp = system_enum.value[0][0] + 3
+            case cls.LONG:
+                max_exp = system_enum.value[0][0] + 6
+            case cls.INDIAN:
+                max_exp = 19
+            case _:
+                raise ValueError("Invalid numbering system")
+        return 10**max_exp - 1
+
+
+class NumberWords(Enum):
+    ONES: ClassVar = {
+        0: "",
+        1: "one",
+        2: "two",
+        3: "three",
+        4: "four",
+        5: "five",
+        6: "six",
+        7: "seven",
+        8: "eight",
+        9: "nine",
+    }
+
+    TEENS: ClassVar = {
+        0: "ten",
+        1: "eleven",
+        2: "twelve",
+        3: "thirteen",
+        4: "fourteen",
+        5: "fifteen",
+        6: "sixteen",
+        7: "seventeen",
+        8: "eighteen",
+        9: "nineteen",
+    }
+
+    TENS: ClassVar = {
+        2: "twenty",
+        3: "thirty",
+        4: "forty",
+        5: "fifty",
+        6: "sixty",
+        7: "seventy",
+        8: "eighty",
+        9: "ninety",
+    }
+
+
+def convert_small_number(num: int) -> str:
+    """
+    Converts small, non-negative integers with irregular constructions in English (i.e.,
+    numbers under 100) into words.
+
+    >>> convert_small_number(0)
+    'zero'
+    >>> convert_small_number(5)
+    'five'
+    >>> convert_small_number(10)
+    'ten'
+    >>> convert_small_number(15)
+    'fifteen'
+    >>> convert_small_number(20)
+    'twenty'
+    >>> convert_small_number(25)
+    'twenty-five'
+    >>> convert_small_number(-1)
+    Traceback (most recent call last):
+    ...
+    ValueError: This function only accepts non-negative integers
+    >>> convert_small_number(123)
+    Traceback (most recent call last):
+    ...
+    ValueError: This function only converts numbers less than 100
+    """
+    if num < 0:
+        raise ValueError("This function only accepts non-negative integers")
+    if num >= 100:
+        raise ValueError("This function only converts numbers less than 100")
+    tens, ones = divmod(num, 10)
+    if tens == 0:
+        return NumberWords.ONES.value[ones] or "zero"
+    if tens == 1:
+        return NumberWords.TEENS.value[ones]
+    return (
+        NumberWords.TENS.value[tens]
+        + ("-" if NumberWords.ONES.value[ones] else "")
+        + NumberWords.ONES.value[ones]
+    )
+
+
+def convert_number(
+    num: int, system: Literal["short", "long", "indian"] = "short"
+) -> str:
+    """
+    Converts an integer to English words.
+
+    :param num: The integer to be converted
+    :param system: The numbering system (short, long, or Indian)
+
+    >>> convert_number(0)
+    'zero'
+    >>> convert_number(1)
+    'one'
+    >>> convert_number(100)
+    'one hundred'
+    >>> convert_number(-100)
+    'negative one hundred'
+    >>> convert_number(123_456_789_012_345) # doctest: +NORMALIZE_WHITESPACE
+    'one hundred twenty-three trillion four hundred fifty-six billion
+    seven hundred eighty-nine million twelve thousand three hundred forty-five'
+    >>> convert_number(123_456_789_012_345, "long") # doctest: +NORMALIZE_WHITESPACE
+    'one hundred twenty-three thousand four hundred fifty-six milliard
+    seven hundred eighty-nine million twelve thousand three hundred forty-five'
+    >>> convert_number(12_34_56_78_90_12_345, "indian") # doctest: +NORMALIZE_WHITESPACE
+    'one crore crore twenty-three lakh crore
+    forty-five thousand six hundred seventy-eight crore
+    ninety lakh twelve thousand three hundred forty-five'
+    >>> convert_number(10**18)
+    Traceback (most recent call last):
+    ...
+    ValueError: Input number is too large
+    >>> convert_number(10**21, "long")
+    Traceback (most recent call last):
+    ...
+    ValueError: Input number is too large
+    >>> convert_number(10**19, "indian")
+    Traceback (most recent call last):
+    ...
+    ValueError: Input number is too large
+    """
+    word_groups = []
+
+    if num < 0:
+        word_groups.append("negative")
+        num *= -1
+
+    if num > NumberingSystem.max_value(system):
+        raise ValueError("Input number is too large")
+
+    for power, unit in NumberingSystem[system.upper()].value:
+        digit_group, num = divmod(num, 10**power)
+        if digit_group > 0:
+            word_group = (
+                convert_number(digit_group, system)
+                if digit_group >= 100
+                else convert_small_number(digit_group)
+            )
+            word_groups.append(f"{word_group} {unit}")
+    if num > 0 or not word_groups:  # word_groups is only empty if input num was 0
+        word_groups.append(convert_small_number(num))
+    return " ".join(word_groups)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+
+    print(f"{convert_number(123456789) = }")