Dérécursification des « nombres en lettres »

Après avoir créé un programme récursif de traduction en français d’un nombre exprimé sous sa forme numérique, nous allons maintenant voir une façon itérative de réaliser cela, mais en changeant un peu les structures de données de façon à montrer qu’il existe d’autres possibilités de faire la même chose (ceci dans un but éducatif, bien évidemment)

Spécificité de l’algorithme

Nous allons construire la chaîne en prenant chaque chiffre à partir de la droite et en répétant la boucle jusqu'à ce que l'on arrive au premier chiffre de gauche. Cette démarche a pour avantage de générer à chaque fois un résultat temporaire que l'on peut assez facilement utiliser à la boucle suivante pour traiter en particulier les cas spéciaux liés aux accords du pluriel ('s') , aux traits d'union et autres ('un' , 'et' … ) . On n’aura plus qu’à faire la concaténation progressive des résultats obtenus. Par contre, cette évaluation s'effectue dans le sens inverse de la lecture naturelle des nombres (c’est à dire de la droite vers la gauche), c’est pourquoi à chaque groupe de trois chiffres on rajoutera l’unité correspondante : mille, million, milliard…

Algorithme

Pour commencer, on va créer des tableaux avec des chaînes de caractères.

On crée un tableau des unités avec les nombres qui ne peuvent pas se décomposer : zéro, un, deux, …, seize : on voit qu’il regroupe les unités et les nombres de dix à seize. Les nombres dix-sept, dix-huit, dix-neuf seront quant à eux logiquement traités en deux étapes (« dix » puis le chiffre restant).

On crée ensuite un tableau des dizaines qui contient les nombres vingt, trente, quarante, cinquante, soixante, quatre-vingt. ("soixante-dix" et "quatre-vingt-dix" n’y figurent pas, étant des cas spéciaux).

On crée ensuite un tableau qui contient les unités restantes : cent, mille, million, milliard, etc.

On suppose que le nombre est entier.

Si le nombre extrait est 0 alors on renvoie « zéro ».

275<>0 , donc on continue

Début de la boucle :

Considérons les deux exemples suivants : les nombres 275 et 398.

On va les découper en tranches de 3 chiffres, à partir de la fin et répéter ce qui suit jusqu’à ce qu’on soit tout à gauche du nombre initial (donc à son début) : à chaque étape de la boucle on divise le nombre par 1000, donc on va arriver à 0 tôt ou tard, auquel cas on s’arrête.

NB : par souci de clarté, on n’entrera pas ici dans le détail des accords du pluriel, des traits d’union etc…

1^ère étape : On récupère d’abord le chiffre des unités, suivi immédiatement de celui des dizaines afin de traiter les cas spéciaux de la langue française.

nombre = 275, nombre=398

unités=5 , nombre restant=27 unités=8, nombre restant=39

dizaines=7, nombre restant= 2 dizaines=9, nombre restant= 3

Soit  temp  une variable auxiliaire de type chaîne, qui est vide.

Temp := ’’ ; temp := ’’ ;

Si le chiffre des dizaines est « 1,7,9 » alors on décrémente ce chiffre et on incrémente de 10 le chiffre des unités.

Dizaines=6, unités=15 dizaines=8, unités=18

Si le chiffre des dizaines est supérieur à 1, alors on initialise temp avec la valeur correspondante (lue dans le tableau des dizaines)

Temp :=’soixante’ ; temp :=’quatre vingt’ ;

Si on a un nombre des dizaines plus petit que 8 et si on a un « un » ou « onze » alors rajouter le mot « et »

On n’est pas concerné par ce cas. On n’est pas concerné par ce cas.

Si le nombre des unités est supérieur à seize, alors on rajoute un espace et « dix » à temp et on décrémente le nombre des unités de 10. On se retrouve donc avec un nombre des dizaines décrémenté de 1, et le nombre des unités compris entre 1 et 16.

On n’est pas concerné par ce cas. Temp :=’quatre vingt dix’ ;

unités := unités-10 = 18-10 = 8 ;

Si le nombre des unités est plus grand que zéro alors on rajoute à temp la chaîne correspondante aux unités.

Temp :=’soixante’ + ’quinze’ = temp :=’quatre vingt dix’ + ’huit’ =

‘soixante quinze’ ; ’quatre vingt dix huit’ ;

On mémorise le résultat dans une autre variable.

Result := ‘soixante quinze’ ; Result :=’quatre vingt dix huit’ ;

2^ème étape : on étudie maintenant le 3è chiffre à partir de la droite …

On récupère le chiffre des centaines et on divise le nombre restant par 10.

C :=2 ; nombre restant := 0 ; C :=3 ; nombre restant := 0 ;

Si le chiffre des centaines est supérieur à 1, alors on va récupérer l’unité correspondante :

Temp :=’deux’ ; Temp :=’trois’ ;

On rajoute ‘cent’ à cette variable :

Temp :=’deux cent’ ; Temp :=’trois cent’ ;

Si le résultat mémorisé est nul, alors on rajoute un ‘s’ sinon on ne fait rien

On n’est pas concerné par ce cas. On n’est pas concerné par ce cas.

On colle ces deux résultats :

Result :=’deux cent’+  Result :=’trois cent’ +

’soixante quinze’ = ’quatre vingt dix huit’ =

’deux cent soixante quinze’ ; ’trois cent quatre vingt dix huit’ ;

On regarde si on doit rajouter mille, million ou milliard. Ceci se fait à l’aide d’un compteur auxiliaire qui est incrémenté à chaque pas de la boucle.

On n’est pas concerné par ce cas. On n’est pas concerné par ce cas.

Fin de la boucle

Télécharger le code source Delphi