Discussion :

[bicha_27]

salut;
je veux réaliser une application pour mon petit projet je dois convertir des chiffres en lettres c'est a dire 1 on un, 2 on deux ect.....
voila avec un button un edit et un label
merci de m'aidez

[Kaamui]

salut;
je veux réaliser une application pour mon petit projet je dois convertir des chiffres en lettres c'est a dire 1 on un, 2 on deux ect.....
voila avec un button un edit et un label
merci de m'aidez

Un petit café avec ?

Sinon sers toi de Qt (par exemple) pour l'interface, et de ta tête pour la conversion.

Edit : Oodini a été plus sympa que moi^^

[Falckounet]

Je ne connais que les solutions un peu sauvage mais je :

1- décomposerais bien le chiffre en digit
2- avec un switch / case j'ai une association digit <-> mot
3- avec un compteur sur la décomposition en digit je sais que c'est une unité/dizaine/centaine/... et je met les "-" et/ou "cent, mil, ..." là où il faut.

Rapido et à la louche mais ça devrait fonctionner.

[Neckara]

Je ne connais que les solutions un peu sauvage mais je :

1- décomposerais bien le chiffre en digit
2- avec un switch / case j'ai une association digit <-> mot
3- avec un compteur sur la décomposition en digit je sais que c'est une unité/dizaine/centaine/... et je met les "-" et/ou "cent, mil, ..." là où il faut.

Rapido et à la louche mais ça devrait fonctionner.

Même pas la peine, il cherche à convertir des chiffres un simple tableau fait l'affaire, il n'y a que 10 possibilités.

Par contre s'il souhaite convertir des nombres le mieux est de faire un tableau de chiffres.
Ensuite il faudra parcourir ce tableau du chiffre de poids le plus fort au chiffre de poids le plus faible.
On peut aussi décider de faire des regroupements de 3 chiffres avec un tableau de 1000 chaînes de caractères pour les convertions. Ainsi pour chaque regroupement on fera : char * nombre = conversion[regroupement]

[ternel]

Otez-moi un doute, pour 15 et 95, on dit bien "dix-cinq" et "nonante-cinq"?
Et bien sûr "trente-un".

Trève de taquinerie, les nombres sont bien plus complexe à traduire que les chiffres, parce que notre chère langue française est pleine de subtilités.

Par exemple, "quatre-vingts" mais "quatre-vingt un" (le pluriel n'est mis que si aucun chiffre non nul ne suit). De même "trois cents" mais "deux cent un".
Et pour comble de bonheur, mille est invariable.

[Neckara]

Une solution de facilité est de regrouper les chiffres par trois et d'avoir dans un tableau les nombres de 0 à 999.

Sinon, si on part du poids fort vers le poids faible, ce n'est pas compliqué, c'est juste un petit peu long à regrouper toutes les règles de la langue française comme le fait remarquer leternel mais au final, ce ne sont que des bêtes if/else.

On pourrait même utiliser des tableaux de pointeurs de fonctions si on veut traiter les chiffres un à un.

exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
char nombre[21];
std::string = "";
for(int i = 20; i != -1; --i)
        std::string += traiterChiffre[i%3](nombre, i);
         // [i%3] : on détermine si on traite des unités, dizaines ou centaines.
         //nombre : le nombre traité
         //passage du compteur par référence si jamais la fonction de traitement traite plusieurs chiffres à la fois (ex : 15)

Et par exemple une fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
traiterUnite(char * nombre, int & i)
{
         std::string retour = unite[ nombre[i] ];
         retour += gpSuivant[i/3](nombre, i); //manque d'inspiration pour nommer ce tableau de fonctions
         return retour;
 
}
 
traiterDizaine(char * nombre, int & i)
{
        if(nombre[i] == 1)
               return tableauContenantLesNombresA2ChiffresAyant1PourChiffreDesDizaines[nombre[i-1] ];
       if(nombre[i] == 2 && ...)
        ...;
}

Donc voilà, ce n'est pas vraiment la mer à boire, le plus dur reste de trouver des noms de variables et de fonctions appropriées^^

[jblecanard]

Hello

Je me suis prêté à l'exercice par curiosité, ce fut un peu plus dur que prévu mais que je crois que j'y suis arrivé. Le code est dispo ici et ça supporte toutes les valeurs d'un int sur 4 octets.

[Neckara]

Pas mal du tout mais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
    int milliards = i / 1000000000;
    int reste_milliards = i % 1000000000;
    int millions = reste_milliards / 1000000;
    int reste_millions = reste_milliards % 1000000;
    int milliers = reste_millions / 1000;
    int reste_milliers = reste_millions % 1000;
 
    if(0 < milliards) {
      result_stream << traiter_inferieur_1000(milliards,false) << "milliard" << ((1 < milliards) ? m_suffixe_pluriel : m_vide) << ((millions || milliers || reste_milliers) ? m_espace : m_vide);
    }
 
    if(0 < millions) {
      result_stream << traiter_inferieur_1000(millions,false) << "million" << ((1 < millions) ? m_suffixe_pluriel : m_vide) << ((milliers || reste_milliers) ? m_espace : m_vide);
    }
 
    if(0 < milliers) {
      result_stream << (1 < milliers ? traiter_inferieur_1000(milliers,false) : m_vide) << "mille" << (reste_milliers ? m_espace : m_vide);
    }
 
    result_stream << traiter_inferieur_1000(reste_milliers);

Je pense qu'il aurait été plus sage d'utiliser une boucle avec un tableau contenant "millier", "million", "milliard" ...
Ainsi on peut facilement repousser les limites si on le souhaite pour aller jusqu'à plusieurs trilliard (même si on ne doit pas en avoir beaucoup d'utilité).

[jblecanard]

Je pense qu'il aurait été plus sage d'utiliser une boucle avec un tableau contenant "millier", "million", "milliard" ...
Ainsi on peut facilement repousser les limites si on le souhaite pour aller jusqu'à plusieurs trilliard (même si on ne doit pas en avoir beaucoup d'utilité).

J'y ai pensé après coup mais pas le temps de ré-écrire, j'y avais passé assez de temps ^^

Et attention : mille a un traitement particulier car il n'est pas accordé au pluriel et on dit "mille" et pas "un mille" (mais on dit "un million"). Le tableau en marche qu'à partir de millions et un int en 4 octets n'excédant pas 2 millards et quelque... flemme.

[Neckara]

Tu t'es déjà prêté au jeux, tu as même fournit un exemple de code qui sera sûrement très utile au P.O., c'est déjà très bien.

Je faisais surtout ces remarques pour montrer quelques petites améliorations possibles que le P.O. pourrait effectuer plutôt que de faire un bête copié-collé du code.