C-Sharp Integer

Conversion des Entiers en Nombres Écrits en C#

Avez-vous déjà eu besoin de convertir des entiers en leur forme écrite ? C’est une exigence courante dans diverses applications, telles que la génération de rapports, la rédaction de chèques, ou tout simplement pour rendre les nombres plus lisibles dans un contenu textuel. Par exemple, vous pourriez avoir besoin de convertir le nombre 21 en "Vingt et Un".

Mais que faire si vous souhaitez une solution qui ne repose pas sur une énorme table de recherche ? Dans cet article de blog, nous allons explorer une méthode simple et efficace en C# pour convertir des entiers en nombres écrits.

Le Problème

Pour convertir des entiers en forme écrite, de nombreux développeurs ont tendance à utiliser de grandes tables de recherche, ce qui peut être encombrant et difficile à maintenir. Au lieu de cela, nous allons explorer une solution plus élégante utilisant la manipulation de chaînes de base et la récursion.

La Solution

Nous pouvons atteindre notre objectif avec une classe personnalisée qui utilise des tableaux pour catégoriser les nombres et une fonction récursive pour construire la forme écrite de manière incrémentale. Décomposons-le étape par étape.

La Classe `HumanFriendlyInteger`

La classe suivante contient la méthode pour convertir des entiers en leurs équivalents écrits :

public static class HumanFriendlyInteger
{
    static string[] ones = new string[] { "", "Un", "Deux", "Trois", "Quatre", "Cinq", "Six", "Sept", "Huit", "Neuf" };
    static string[] teens = new string[] { "Dix", "Onze", "Douze", "Treize", "Quatorze", "Quinze", "Seize", "Dix-Sept", "Dix-Huit", "Dix-Neuf" };
    static string[] tens = new string[] { "Vingt", "Trente", "Quarante", "Cinquante", "Soixante", "Soixante-Dix", "Quatre-Vingt", "Quatre-Vingt-Dix" };
    static string[] thousandsGroups = { "", " Mille", " Million", " Milliard" };

    private static string FriendlyInteger(int n, string leftDigits, int thousands)
    {
        // Gestion des cas spéciaux en fonction de la valeur du nombre
        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] + " Cent"), 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 "Zéro";
        }
        else if (n < 0)
        {
            return "Négatif " + IntegerToWritten(-n);
        }

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

Décomposition du Code

Tableaux Statique : La classe utilise quatre tableaux statiques pour stocker les formes écrites des nombres :
- ones : Contient les mots pour les nombres 1-9.
- teens : Contient les mots pour les nombres 10-19.
- tens : Contient les mots pour les multiples de dix (20, 30, etc.).
- thousandsGroups : Contient les mots pour des valeurs supérieures comme mille, million, etc.
Méthode FriendlyInteger : Cette méthode récursive décompose le nombre en parties gérables :
- Elle gère la construction des nombres en fonction de leur taille (unités, adolescents, dizaines, centaines et milliers).
- Chaque appel construit récursivement la représentation en chaîne en vérifiant à quelle catégorie appartient le nombre.
Méthode IntegerToWritten : C’est la méthode publique pour convertir des entiers. Elle gère les zéros et les nombres négatifs avant d’appeler la méthode FriendlyInteger.

Conclusion

En utilisant cette méthode, vous pouvez convertir efficacement des entiers en leur forme écrite en C#. Cette solution est non seulement élégante mais évite également le souci de maintenir d’énormes tables de recherche.