C-Sharp Integer

Convirtiendo Enteros a Números Escritos en C#

¿Alguna vez has necesitado convertir enteros a su forma escrita? Este es un requisito común en varias aplicaciones, como la generación de informes, la redacción de cheques o simplemente para hacer que los números sean más fáciles de leer en contenido textual. Por ejemplo, es posible que necesites convertir el número 21 a "Veintiuno".

Pero, ¿qué pasa si quieres una solución que no dependa de una gran tabla de referencia? En esta publicación del blog, exploraremos un método ordenado y eficiente en C# para convertir enteros en números escritos.

El Problema

Para convertir enteros a su forma escrita, muchos desarrolladores suelen recurrir a usar tablas de referencia grandes, las cuales pueden ser engorrosas y difíciles de mantener. En su lugar, exploraremos una solución más elegante utilizando manipulación de cadenas básica y recursión.

La Solución

Podemos lograr nuestro objetivo con una clase personalizada que utiliza arreglos para categorizar los números y una función recursiva para construir la forma escrita de manera incremental. Vamos a desglosarlo paso a paso.

La Clase `HumanFriendlyInteger`

La siguiente clase contiene el método para convertir enteros en sus equivalentes escritos:

public static class HumanFriendlyInteger
{
    static string[] ones = new string[] { "", "Uno", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "Ocho", "Nueve" };
    static string[] teens = new string[] { "Diez", "Once", "Doce", "Trece", "Catorce", "Quince", "Dieciséis", "Diecisiete", "Dieciocho", "Diecinueve" };
    static string[] tens = new string[] { "Veinte", "Treinta", "Cuarenta", "Cincuenta", "Sesenta", "Setenta", "Ochenta", "Noventa" };
    static string[] thousandsGroups = { "", " Mil", " Millón", " Mil millones" };

    private static string FriendlyInteger(int n, string leftDigits, int thousands)
    {
        // Manejo de casos especiales según el valor del número
        if (n == 0)
        {
            return leftDigits;
        }

        string friendlyInt = leftDigits;

        if (friendlyInt.Length > 0)
        {
            friendlyInt += " ";
        }

        if (n < 10)
        {
            friendlyInt += ones[n];
        }
        else if (n < 20)
        {
            friendlyInt += teens[n - 10];
        }
        else if (n < 100)
        {
            friendlyInt += FriendlyInteger(n % 10, tens[n / 10 - 2], 0);
        }
        else if (n < 1000)
        {
            friendlyInt += FriendlyInteger(n % 100, (ones[n / 100] + " Cien"), 0);
        }
        else
        {
            friendlyInt += FriendlyInteger(n % 1000, FriendlyInteger(n / 1000, "", thousands + 1), 0);
            if (n % 1000 == 0)
            {
                return friendlyInt;
            }
        }

        return friendlyInt + thousandsGroups[thousands];
    }

    public static string IntegerToWritten(int n)
    {
        if (n == 0)
        {
            return "Cero";
        }
        else if (n < 0)
        {
            return "Negativo " + IntegerToWritten(-n);
        }

        return FriendlyInteger(n, "", 0);
    }
}

Desglose del Código

Arreglos Estáticos: La clase utiliza cuatro arreglos estáticos para almacenar las formas escritas de los números:
- ones: Contiene las palabras para los números 1-9.
- teens: Contiene las palabras para los números 10-19.
- tens: Contiene las palabras para los múltiplos de diez (20, 30, etc.).
- thousandsGroups: Contiene las palabras para valores mayores como mil, millón, etc.
Método FriendlyInteger: Este método recursivo descompone el número en partes manejables:
- Maneja los constructos de los números según sus tamaños (unidades, decenas, centenas y miles).
- Cada llamada construye recursivamente la representación de cadena verificando a qué categoría pertenece el número.
Método IntegerToWritten: Este es el método público para convertir enteros. Maneja cero y números negativos antes de llamar al método FriendlyInteger.

Conclusión

Al utilizar este método, puedes convertir eficientemente enteros a su forma escrita en C#. Esta solución no solo es elegante, sino que también evita el inconveniente de mantener amplias tablas de referencia.