Discussion :

[jazzepa]

bonjour,
Je suis étudiant et je n'ai jamais fais de programmation en C, on me demande de faire un programme qui consiste à taper un chiffre numérique et le programme doit convertir en lettre donc pouvez vous m'aidez svp ? merci d'avance !


je vous joins le descriptif exact :

1. Présentation du sujet du devoir
Il s'agit d'écrire un algorithme qui traduit en toutes lettres un nombre entier positif inférieur à un million (0-999999). Les nombreuses exceptions de la langue française fournissent avec cet exercice un sujet classique d'algorithmique.
Le principe de base que vous allez adopter pour ce problème consiste à isoler les chiffres constituant le nombre et à énoncer chaque chiffre suivi de sa valeur (mille, cent..)
Ainsi 305234 s'écrit : trois cent cinq mille deux cent trente-quatre.
Les chiffres exprimant les dizaines et celui des unités sont reliés par un tiret (trente-trois, soixante-huit).
« Quelques » exceptions existent tout de même...
1.Le chiffre des dizaines doit être traité différemment : on écrit trente-quatre et non trois dix quatre.
2.Le chiffre 1 n'est pas écrit s'il précède mille ou cent : on écrit mille trois cent vingt-huit et non un mille trois cent vingt-huit.
3.Les nombres de 11 à 16 n'obéissent pas à la règle générale : onze au lieu de dix-un, ... seize au lieu de dix-six.
4.Quand une dizaine est suivie de un, il faut rajouter la conjonction et entre les deux : on écrit trente-et-un et non trente-un. Attention toutefois, ceci ne s'applique ni pour quatre-vingt-un, ni pour quatre-vingt-onze. A noter, enfin, une exception dans l'exception, car on dit bien soixante-et-onze...
5.De 61 à 79 (respectivement de 81 à 99) on écrit soixante (respectivement quatre-vingt) suivi de l'expression du nombre compris entre 1 et 19).
6.Quand cent et vingt sont précédés d'un chiffre et terminent le nombre, ils prennent un « s ». deux cents (200), quatre-vingts (80), mais quatre-vingt-trois (83), deux cent mille (200000) et quatre-vingt mille trois cent quarante-sept (80347).
7.Attention au cas très particulier du « zéro » qui ne s'écrit que lorsque le nombre à traduire en lettre vaut 0...

2. Travail à réaliser
Il vous est demandé de concevoir un programme qui affiche à l'écran le nombre en toutes lettres saisi par l'utilisateur au clavier. L'écriture des algorithmes puis le programmation en C de ces mécanismes doivent être réalisées dans le cadre de ce devoir en suivant scrupuleusement les indications ci-après.

3. Démarche à adopter
1. Structuration du programme et réflexion préliminaires (§1.7)
En remarquant que le traitement des trois chiffres du rang des milliers est assez similaire à
celui du rang des unités, le programme peut être bâti autour d'un sous-programme capable
d'effectuer la traduction d'un nombre compris entre 0 et 999. Existe-t-il des différences entre
le traitement des milliers et des unités ? Si oui, quelle information doit être transmise au
sous-programme (en plus de la valeur à traduire bien sûr) pour qu'il puisse s'exécuter
correctement ? Donner la déclaration d'un tel sous programme dont l'identificateur sera
Traduire (le corps de ce sous-programme ne sera pas étudié à ce stade, vous vous
contenterez des deux délimiteurs début et fin).
2. Bloc de programme appelant le sous programme Traduire (§1.2, 1.3, 1.4, 1.5)
Le traitement dans ce bloc doit enchaîner, la lecture du nombre à traduire, la vérification que la
valeur est comprise dans la plage prévue et l'appel au sous programme Traduire.
Décomposer soigneusement ces étapes de façon à pouvoir les écrire en utilisant le
formalisme de l'algorithmique. Attention, le cas ou le nombre saisi est 0 est très particulier.
N'oubliez pas les déclarations des variables, constantes ou types nécessaires pour votre
algorithme dans un dictionnaire de données (voir les exemples de la section 8 du polycopié).
3. Écriture du bloc de programme du sous-programme Traduire (§1.2, 1.3, 1.4, 1.5)
3.1 Réflexions préliminaires
La traduction en lettre d'un chiffre peut être assurée par un tableau dont de chaînes de
caractères dont la chaîne correspond à la traduction de l'indice du tableau qui permet d'y
accéder (0 -> « zero », 2-> « deux », etc.). Peut-on se contenter des chiffres de 0 à 9?
En déduire la déclaration de ce tableau de correspondance « valeur -> chaîne ». Peut-on
utiliser le même principe pour le chiffre des dizaines ? Donner la déclaration du tableau
correspondant.
3.2 extraction des trois chiffres du nombre à traduire.
Ce traitement est préliminaire à tout ce qui suit. Écrire les deux ou trois lignes d'algorithme
qui permettent cette extraction dans trois variables (Centaine, Dizaine, Unite).
3.3 algorithme pour les centaines.
Donner l'algorithme qui permet d'écrire un chiffre suivi du mot « cent ». Attention aux
exceptions qui devront être traitées en priorité. Rappelez-vous en particulier que « cent »
ne prend jamais de « s » s'il est suivi du mot mille, que l'on n'écrit pas « un cent », etc...
3.4 Algorithme pour les dizaines et les unités.
Ici encore le traitement de ces deux chiffres doit d'abord résoudre les exceptions avant
d'appliquer la méthode standard qui peut se résumer à :
ecrire (dizaine, "-",unite);
Ne pas oublier également que vingt ne prends pas de « s » s'il est suivi de mille.

4. Algorithme complet
Donner enfin l'algorithme complet de votre solution accompagné du dictionnaire des données. Vous serez très attentifs à cette étape de bien suivre les recommandations d'écriture données dans le polycopié. Plus votre algorithme sera écrit soigneusement, plus la traduction en langage C sera aisée..

5. Codage de votre solution
Transformer l'algorithme en code C puis le compiler et effectuer la mise au point. Vous vous bornerez à utiliser de l'ANSI C pour assurer la portabilité de votre solution.
Au cours de cette phase de mise au point, vous vous attacherez à comprendre les éventuelles erreurs, à corriger les parties d'algorithme correspondantes puis à modifier le code source pour prendre en compte ces modifications. Sauf s'il s'agit d'une erreur introduite par l'étape de codage elle-même, ne corrigez jamais le code source en C avant d'avoir résolu le problème en algorithmique !

Ce qui est attendu par le correcteur
1. L'algorithme complet de la solution (avec son dictionnaire de données) tel qu'il est demandé à la question 4. Cet algorithme devra être suffisamment commenté pour être compréhensible sans trop d'effort par le correcteur.
2. Le code source du programme en langage C correspondant exactement à l'algorithme. La encore, des commentaires sur les parties vous semblant les plus délicates seront les bienvenues.
3. La liste des valeurs pour lesquelles le programme a été testé et fonctionne. Éventuellement, la liste des valeurs pour lesquelles le programme a été testé et ne fonctionne pas.

[pythéas]

Bonjour,

L'idée du forum c'est plutôt d'aider quelqu'un qui bloque sur un point précis que de faire des exercices à la place des étudiants.
Tu peux bien commencer quelque chose, lire les caractères à l'écran, faire au moins un "if" pour le "zéro"...
Enfin, c'est pas pour te faire la morale mais autant tu trouveras sur ce forum des tas de gens ravis de te donner un coup de main autant personne ne fera l'exercice à ta place.

[ternel]

Par ailleurs, tu n'as jamais fait de C? Ce n'est pas grave.
Fais déjà l'algorithme. Il s'agit tout simplement d'expliquer formellement la tache à accomplir.

L'énoncé est assez long (je ne l'ai pas lu, je l'ai aperçu) pour être assez détaillé… Réfléchit un peu.

Comment t'y prendrais-tu, toi, pour convertir 1245 en mille deux cents quarante-cinq?

[Obsidian]

bonjour,
Je suis étudiant et je n'ai jamais fais de programmation en C, on me demande de faire un programme qui consiste à taper un chiffre numérique et le programme doit convertir en lettre donc pouvez vous m'aidez svp ? merci d'avance !

Avant toute chose, comment t'es-tu retrouvé à devoir écrire un programme en C sans jamais avoir vu ce langage ?

Ensuite, dans le cas où il s'agirait justement du premier TP de ton premier cours de C, qu'as-tu écrit jusqu'ici ?

[devdeb91]

bonjour

selon moi pour commencer tu pourrais demander a l'utilisateur d'entrer la valeur et cette valeur serai un tableau d'entier.

puis tu pourrais parcourir ce tableau pour compter le nombre de chiffre ainsi tu pourrai savoir si c'est un chiffre ou un nombre et aussi de combien à combien il irai ( exemple : 500 = 3 chiffre donc il sera entre 100 et 999) cela te permettrai de traduire le nombre plus facilement toujours même exemple 500 tu prend le premier chiffre c'est 5 donc cinq et cent derrière.

voila aprés a toi de voir pour le reste

[diogene]

Et si l'utilisateur tape "0500" ou " 500" ?

[devdeb91]

Et si l'utilisateur tape "0500" ou " 500" ?

bah dans se cas la tu fait en sorte de vérifier cela imaginon que c'est 0500 tu met un if ou un tant que c'est pas different de 0 il continue a parcourir une fois que c'est différent de 0 il se place et commence le compteur .

ou aussi il peut prendre sa sous forme de chaine de caractere qu'il parcourera une fois qu'il tombe sur un chiffre entre 1 et 9 il commence le compteur et le place dans un nouveau tableau une fois arriver au '/0' il met des if pour le compteur du genre if(cpt = 4 ) { printf("%d mille %d cent %d", tabfinal[0], tabfinal[1], ; } etc... a lui d'arranger aprés mais c'est un bon debut de mon point de vue aprés pas forcement la meilleure facon

[Sve@r]

Bonjour

Je suis étudiant

En quoi ? En informatique ???

et je n'ai jamais fais de programmation en C on me demande de faire un programme qui consiste à taper un chiffre numérique et le programme doit convertir en lettre

Absolument invraisemblable. Les débutants on leur fait faire des tests "nombre pair/nombre impair; des jeux "plus petit/plus grand". Ce genre d'exercice est déjà d'un niveau bien confirmé. Maintenant si tu n'as jamais écouté/étudié en cours ce n'est pas la même chose...

[edit] Je viens de lire l'énoncé. Aller jusqu'à spécifier quand mettre un "s" et quand ne pas en mettre c'est pas confirmé comme niveau, c'est carrément un truc niveau fin de cours. Je comprends que celui qui n'a jamais fait de C soit un peu largué. Même pour les habitués de ce fofo ce serait un joli challenge. Mais de toute façon cela ne te serait d'aucun bénéfice qu'on te le fasse pour toi. Le vrai jour du test, c'est toi qui sera devant l'écran...

bah dans se cas la tu fait en sorte de vérifier cela imaginon que c'est 0500 tu met un if ou un tant que c'est pas different de 0 il continue a parcourir une fois que c'est différent de 0 il se place et commence le compteur .

ou aussi il peut prendre sa sous forme de chaine de caractere qu'il parcourera une fois qu'il tombe sur un chiffre entre 1 et 9 il commence le compteur et le place dans un nouveau tableau une fois arriver au '/0' il met des if pour le compteur du genre if(cpt = 4 ) { printf("%d mille %d cent %d", tabfinal[0], tabfinal[1], ; } etc... a lui d'arranger aprés mais c'est un bon debut de mon point de vue aprés pas forcement la meilleure facon

Plus simplement: sscanf("0000500", "%d", &i) donnera au final i=500. En revanche je ne sais pas comment il se comporte si la chaine commence par des espaces (et j'ai un peu la flemme de regarder). M'enfin même dans le pire des cas c'est pas la mort de gérer les "isspace()" éventuels situés en début de nombre...

[devdeb91]

Plus simplement: sscanf("0000500", "%d", &i) donnera au final i=500. En revanche je ne sais pas comment il se comporte si la chaine commence par des espaces (et j'ai un peu la flemme de regarder). M'enfin même dans le pire des cas c'est pas la mort de gérer les "isspace()" éventuels situés en début de nombre...

certes mais dans un premier temps vue qu'il est debutant peut etre devrait il passer par des boucle et condition que par des fonction toute faite car il les utilisera sans vraiment savoir se qu'il fait

[jazzepa]

je suis étudiant par correspondance et le premier exercice que je dois faire c'est celui ci donc oui c'est clair je suis complètement largué...
non je ne suis pas en informatique, je suis en électronique, électricité
je ne demande pas de me le faire mais que l'on m'explique...
je regarde sur d'autre site pour voir comment on fait un algorithme de facon correct...

[jazzepa]

pour l'algorithme :

DEBUT
Lire n
Afficher n
Si n=0
FAIRE AFFICHER "Zéro"
Si n=1
FAIRE AFFICHER "un"
Si n=2
FAIRE AFFICHER "deux"
Si n=3
FAIRE AFFICHER "trois"
Si n=4
FAIRE AFFICHER "quatre"
Si n=5
FAIRE AFFICHER "cinq"
Si n=6
FAIRE AFFICHER "six"
Si n=7
FAIRE AFFICHER "sept"
Si n=8
FAIRE AFFICHER "huit"
Si n=9
FAIRE AFFICHER "neuf"
Si n=10
FAIRE AFFICHER "dix"
Si n=11
FAIRE AFFICHER "onze"
Si n=12
FAIRE AFFICHER "douze"
Si n=13
FAIRE AFFICHER "treize"
Si n=14
FAIRE AFFICHER "quatorze"
Si n=15
FAIRE AFFICHER "quize"
Si n=16
FAIRE AFFICHER "seize"
Si n=17
FAIRE AFFICHER "dix-sept"
Si n=18
FAIRE AFFICHER "dix-huit"
Si n=19
FAIRE AFFICHER "dix-neuf"
FIN

mais comment on fait pour dire que pour les chiffres 19<n>99 on répète les nombres de 0 à 9 en ajoutant le chiffre de la dizaine ?
et après ça sera la même chose pour les centaines,...

[Obsidian]

Après une lecture plus approfondie, il semblerait que ton devoir consiste principalement à écrire l'algorithme d'une manière générale et de ne le traduire qu'une fois cette partie menée à bien. Autrement dit, ce n'est pas le programme C lui-même qui va te faire gagner le plus de points.

Comme dit plus haut, tu parviens à naturellement énoncer un nombre, par exemple « 14576 » en « Quatorze mille cinq cent soixante-seize » sans avoir à y réfléchir. C'est parce que tu y es habitué depuis la petite enfance, et également parce que les entends pratiquement tous les jours. Tout ce que tu as à faire dès lors est rédiger sur papier la méthode à suivre en utilisant si possible du pseudo-code.

Comme le nombre à traiter est un entier naturel inférieur à un million, les choses sont déjà simplifiées : les parties supérieures et inférieures à mille se traitent de la même façon. Par exemple « 945945 » se dit « neuf cent quarante-cinq mille neuf cent quarante-cinq ». La première chose à faire consiste donc à « séparer les deux moitiés de ton nombre ». Cela se fait en le divisant par mille : le quotient est la partie de gauche, supérieure à mille et le reste est celle de droite.

Tu écris donc une fonction « affiche_millier » qui te permettra d'écrire un nombre de 1 à 999. Puis, dans l'ordre :

• Si n est nul, tu écris « zéro » et tu sors directement ;
• Si la partie de gauche est supérieure à 1, tu appelles affiche_millier() avec cette valeur-ci (supérieure à 1 pour éviter les « un mille ») ;
• Si la partie de gauche est supérieure à 0, tu affiches « mille » ;
• Si la partie de droite est supérieure à zéro, tu appelles affiche_milliers() avec cette valeur-là.

Je te laisse développer le reste pour le moment.

[jazzepa]

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
DEBUT
Si n=0 
FAIRE AFFICHER "Zéro"
Si n=1
FAIRE AFFICHER "un"
Si n=2
FAIRE AFFICHER "deux"
Si n=3
FAIRE AFFICHER "trois"
Si n=4
FAIRE AFFICHER "quatre"
Si n=5
FAIRE AFFICHER "cinq"
Si n=6
FAIRE AFFICHER "six"
Si n=7
FAIRE AFFICHER "sept"
Si n=8
FAIRE AFFICHER "huit"
Si n=9
FAIRE AFFICHER "neuf"
Si n=10
FAIRE AFFICHER "dix"
Si n=11
FAIRE AFFICHER "onze"
Si n=12
FAIRE AFFICHER "douze"
Si n=13
FAIRE AFFICHER "treize"
Si n=14
FAIRE AFFICHER "quatorze"
Si n=15
FAIRE AFFICHER "quinze"
Si n=16
FAIRE AFFICHER "seize"
Si n=17
FAIRE AFFICHER "dix-sept"
Si n=18
FAIRE AFFICHER "dix-huit"
Si n=19
FAIRE AFFICHER "dix-neuf"
 
Si dizaine=2
FAIRE AFFICHER "vingt"
Si dizaine=3
FAIRE AFFICHER "trente et"
Si dizaine=4
FAIRE AFFICHER "quarante et"
Si dizaine=5
FAIRE AFFICHER "cinquante et"
Si dizaine=6
FAIRE AFFICHER "soixante et"
Si n=71
FAIRE AFFICHER "soixante et onze"
Si n=72
FAIRE AFFICHER "soixante douze"
Si n=73
FAIRE AFFICHER "soixante treize"
Si n=74
FAIRE AFFICHER "soixante quatorze"
Si n=75
FAIRE AFFICHER "soixante quinze"
Si n=76
FAIRE AFFICHER "soixante seize"
Si n=77
FAIRE AFFICHER "soixante dix-sept"
Si n=78
FAIRE AFFICHER "soixante dix-huit"
Si n=79
FAIRE AFFICHER "soixante dix-neuf"
Si dizaine=8
FAIRE AFFICHER "quatre vingt"
Si n=91
FAIRE AFFICHER "quatre vingt onze"
Si n=92
FAIRE AFFICHER "quatre vingt douze"
Si n=93
FAIRE AFFICHER "quatre vingt treize"
Si n=94
FAIRE AFFICHER "quatre vingt quatorze"
Si n=95
FAIRE AFFICHER "quatre vingt quinze"
Si n=96
FAIRE AFFICHER "quatre vingt seize"
Si n=97
FAIRE AFFICHER "quatre vingt dix-sept"
Si n=98
FAIRE AFFICHER "quatre vingt dix-huit"
Si n=99
FAIRE AFFICHER "quatre vingt dix-neuf"
 
Si centaine=1
FAIRE AFFICHER "cent"
Si centaine=2
FAIRE AFFICHER "deux cent"
Si centaine=3
FAIRE AFFICHER "trois cent"
Si centaine=4
FAIRE AFFICHER "quatre cent"
Si centaine=5
FAIRE AFFICHER "cinq cent"
Si centaine=6
FAIRE AFFICHER "six cent"
Si centaine=7
FAIRE AFFICHER "sept cent"
Si centaine=8
FAIRE AFFICHER "huit cent"
Si centaine=9
FAIRE AFFICHER "neuf cent"
 
Si millier=1
FAIRE AFFICHER "mille"
Si millier=2
FAIRE AFFICHER "deux mille"
Si millier=3
FAIRE AFFICHER "trois mille"
Si millier=4
FAIRE AFFICHER "quatre mille"
Si millier=5
FAIRE AFFICHER "cinq mille"
Si millier=6
FAIRE AFFICHER "six mille"
Si millier=7
FAIRE AFFICHER "sept mille"
Si millier=8
FAIRE AFFICHER "huit mille"
Si millier=9
FAIRE AFFICHER "neuf mille"
 
Si dizaine_de_millier=1
FAIRE AFFICHER "dix mille"
Si dizaine_de_millier=1 et Si millier=1
FAIRE AFFICHER "onze mille"
Si dizaine_de_millier=1 et Si millier=2
FAIRE AFFICHER "douze mille"
Si dizaine_de_millier=1 et Si millier=3
FAIRE AFFICHER "treize mille"
Si dizaine_de_millier=1 et Si millier=4
FAIRE AFFICHER "quatorze mille"
Si dizaine_de_millier=1 et Si millier=5
FAIRE AFFICHER "quinze mille"
Si dizaine_de_millier=1 et Si millier=6
FAIRE AFFICHER "seize mille"
Si dizaine_de_millier=1 et Si millier=7
FAIRE AFFICHER "dix sept mille"
Si dizaine_de_millier=1 et Si millier=8
FAIRE AFFICHER "dix huit mille"
Si dizaine_de_millier=1 et Si millier=9
FAIRE AFFICHER "dix neuf mille"
Si dizaine_de_millier=2
FAIRE AFFICHER "vingt mille"
Si dizaine_de_millier=3
FAIRE AFFICHER "trente mille"
Si dizaine_de_millier=4
FAIRE AFFICHER "quarante mille"
Si dizaine_de_millier=5
FAIRE AFFICHER "cinquante mille"
Si dizaine_de_millier=6
FAIRE AFFICHER "soixante mille"
Si dizaine_de_millier=7
FAIRE AFFICHER "soixante dix mille"
Si dizaine_de_millier=7 et Si millier=1
FAIRE AFFICHER "soixante et onze mille"
Si dizaine_de_millier=7 et Si millier=2
FAIRE AFFICHER "soixante douze mille"
Si dizaine_de_millier=7 et Si millier=3
FAIRE AFFICHER "soixante treize mille"
Si dizaine_de_millier=7 et Si millier=4
FAIRE AFFICHER "soixante quatorze mille"
Si dizaine_de_millier=7 et Si millier=5
FAIRE AFFICHER "soixante quinze mille"
Si dizaine_de_millier=7 et Si millier=6
FAIRE AFFICHER "soixante seize mille"
Si dizaine_de_millier=7 et Si millier=7
FAIRE AFFICHER "soixante dix sept mille"
Si dizaine_de_millier=7 et Si millier=8
FAIRE AFFICHER "soixante dix huit mille"
Si dizaine_de_millier=7 et Si millier=9
FAIRE AFFICHER "soixante dix neuf mille"
Si dizaine_de_millier=8
FAIRE AFFICHER "quatre vingt mille"
Si dizaine_de_millier=9
FAIRE AFFICHER "soixante dix mille"
Si dizaine_de_millier=9 et Si millier=1
FAIRE AFFICHER "quatre vingt onze mille"
Si dizaine_de_millier=9 et Si millier=2
FAIRE AFFICHER "quatre vingt douze mille"
Si dizaine_de_millier=9 et Si millier=3
FAIRE AFFICHER "quatre vingt treize mille"
Si dizaine_de_millier=9 et Si millier=4
FAIRE AFFICHER "quatre vingt quatorze mille"
Si dizaine_de_millier=9 et Si millier=5
FAIRE AFFICHER "quatre vingt quinze mille"
Si dizaine_de_millier=9 et Si millier=6
FAIRE AFFICHER "quatre vingt seize mille"
Si dizaine_de_millier=9 et Si millier=7
FAIRE AFFICHER "quatre vingt dix sept mille"
Si dizaine_de_millier=9 et Si millier=8
FAIRE AFFICHER "quatre vingt dix huit mille"
Si dizaine_de_millier=9 et Si millier=9
FAIRE AFFICHER "quatre vingt dix neuf mille"
 
Si centaine_de_millier=1
FAIRE AFFICHER "cent mille"
Si centaine_de_millier=2
FAIRE AFFICHER "deux cent mille"
Si centaine_de_millier=3
FAIRE AFFICHER "trois cent mille"
Si centaine_de_millier=4
FAIRE AFFICHER "quatre cent mille"
Si centaine_de_millier=5
FAIRE AFFICHER "cinq cent mille"
Si centaine_de_millier=6
FAIRE AFFICHER "six cent mille"
Si centaine_de_millier=7
FAIRE AFFICHER "sept cent mille"
Si centaine_de_millier=8
FAIRE AFFICHER "huit cent mille"
Si centaine_de_millier=9
FAIRE AFFICHER "neuf cent mille"
FIN

Oui ce n'est pas beau, c'est long mais si on fait comme ça l'algorithme est-il correct ?
Et comment faire pour simplifier de 71 à 79 et de 91 à 90 car c'est un peux comme de 11 à 19 ?

[Obsidian]

Oui ce n'est pas beau, c'est long mais si on fait comme ça l'algorithme est-il correct ?

Pas tout-à-fait : il y a plusieurs erreurs mais j'en vois au moins une rédhibitoire : si tu gères les milliers et dizaines de milliers de la façon dont tu viens de le faire, alors « 19000 » donnerait « neuf mille dix mille » à l'écran.

Ça permet de mettre en évidence le fait qu'on lit — et énonce — un nombre de gauche à droite, c'est-à-dire du poids le plus fort vers le plus faible. Ton programme, d'une certaine manière, devrait donc faire la même chose.

Il y a plusieurs techniques pour factoriser son code et éviter d'avoir à le réécrire en double. Par exemple, pour les nombres de 1 à 19 puis de 80 à 99, il te suffit de commencer par vérifier si le nombre est effectivement supérieur ou égal à 80, afficher « quatre-vingt- » puis soustraire 80 à la variable que tu utilises : tu te retrouveras alors avec « 1 ≤ n ≤ 19 » et le morceau de code suivant entrera automatiquement en action pour compléter ta chaîne, sans savoir si le nombre était dès le départ compris dans cette tranche où si on lui a retranché 80.

Cela dit, je ne t'expose cette méthode qu'à titre d'exemple. Pas la peine de t'embrouiller l'esprit avec pour le moment. Essaie plutôt de suivre les étapes que je t'ai données dans mon précédent commentaire.

[ternel]

pour t'aider, tu devrais remarquer que la numération est écrite par série de "centaines, unités":

123 456 789 s'écrit: "cent" "vingt-trois" "millions" - "quatre cent" "cinquante-six" "mille" - "sept cent" "quatre-vingt-neuf" ""

Partant de là, tu as trois choses à faire:
découper par triplet
encoder chaque triplet en "N cent(s) quelque chose"
encoder les centaines (un chiffre…)
encoder les unités (deux chiffres)
compter les blocs pour savoir quel multiple associer à chaque triplet

[jazzepa]

ok ok et si je fais comme ca :

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
Fonction(unite)
DEBUT
Si n=0 
FAIRE AFFICHER "Zéro"
Si n=1
FAIRE AFFICHER "un"
Si n=2
FAIRE AFFICHER "deux"
Si n=3
FAIRE AFFICHER "trois"
Si n=4
FAIRE AFFICHER "quatre"
Si n=5
FAIRE AFFICHER "cinq"
Si n=6
FAIRE AFFICHER "six"
Si n=7
FAIRE AFFICHER "sept"
Si n=8
FAIRE AFFICHER "huit"
Si n=9
FIN
 
Fonction(dizaine)
FAIRE AFFICHER "neuf"
Si n=10
FAIRE AFFICHER "dix"
Si n=11
FAIRE AFFICHER "onze"
Si n=12
FAIRE AFFICHER "douze"
Si n=13
FAIRE AFFICHER "treize"
Si n=14
FAIRE AFFICHER "quatorze"
Si n=15
FAIRE AFFICHER "quinze"
Si n=16
FAIRE AFFICHER "seize"
Si n=17
FAIRE AFFICHER "dix-sept"
Si n=18
FAIRE AFFICHER "dix-huit"
Si n=19
FAIRE AFFICHER "dix-neuf"
FIN
 
Fonction(a)
DEBUT
Si n=0 
FAIRE AFFICHER " "
Si n=1
FAIRE AFFICHER "et un"
Si n=2
FAIRE AFFICHER "deux"
Si n=3
FAIRE AFFICHER "trois"
Si n=4
FAIRE AFFICHER "quatre"
Si n=5
FAIRE AFFICHER "cinq"
Si n=6
FAIRE AFFICHER "six"
Si n=7
FAIRE AFFICHER "sept"
Si n=8
FAIRE AFFICHER "huit"
Si n=9
FIN
 
Fonction(b)
DEBUT
Si unite=0
FAIRE AFFICHER " "
Si unite=1
FAIRE AFFICHER "onze"
Si unite=2
FAIRE AFFICHER "douze"
Si unite=3
FAIRE AFFICHER "treize"
Si unite=4
FAIRE AFFICHER "quatorze"
Si unite=5
FAIRE AFFICHER "quinze"
Si unite=6
FAIRE AFFICHER "seize"
Si unite=7
FAIRE AFFICHER "dix-sept"
Si unite=8
FAIRE AFFICHER "dix-huit"
Si unite=9
FAIRE AFFICHER "dix-neuf"
FIN
 
Fonction(c)
DEBUT
Si dizaine=2
FAIRE AFFICHER "vingt" et Fonction(a)
Si dizaine=3
FAIRE AFFICHER "trente" et Fonction(a)
Si dizaine=4
FAIRE AFFICHER "quarante" et Fonction(a)
Si dizaine=5
FAIRE AFFICHER "cinquante" et Fonction(a)
Si dizaine=6
FAIRE AFFICHER "soixante" et Fonction(a)
Si dizaine=7
FAIRE AFFICHER "soixante et " et Fonction(b)
Si dizaine=8
FAIRE AFFICHER "quatre vingt" et Fonction(a)
Si diziane=9
FAIRE AFFICHER "quatre vingt" et Fonction(b)
FIN
 
Fonction(d)
DEBUT
Si centaine=0 
FAIRE AFFICHER " " et Fonction(c)
Si centaine=1
FAIRE AFFICHER "cent" et Fonction(c)
Si centaine=2
FAIRE AFFICHER "deux cent" et Fonction(c)
Si centaine=3
FAIRE AFFICHER "trois cent" et Fonction(c)
Si centaine=4
FAIRE AFFICHER "quatre cent" et Fonction(c)
Si centaine=5
FAIRE AFFICHER "cinq cent" et Fonction(c)
Si centaine=6
FAIRE AFFICHER "six cent" et Fonction(c)
Si centaine=7
FAIRE AFFICHER "sept cent" et Fonction(c)
Si centaine=8
FAIRE AFFICHER "huit cent" et Fonction(c)
Si centaine=9
FAIRE AFFICHER "neuf cent" et Fonction(c)
FIN
 
Fonction(e)
DEBUT
Si millier=0
FAIRE AFFICHER " " et Fonction(d)
Si millier=1
FAIRE AFFICHER "mille" et Fonction(d)
Si millier=2
FAIRE AFFICHER "deux mille" et Fonction(d)
Si millier=3
FAIRE AFFICHER "trois mille" et Fonction(d)
Si millier=4
FAIRE AFFICHER "quatre mille" et Fonction(d)
Si millier=5
FAIRE AFFICHER "cinq mille" et Fonction(d)
Si millier=6
FAIRE AFFICHER "six mille" et Fonction(d)
Si millier=7
FAIRE AFFICHER "sept mille" et Fonction(d)
Si millier=8
FAIRE AFFICHER "huit mille" et Fonction(d)
Si millier=9
FAIRE AFFICHER "neuf mille" et Fonction(d)
FIN
 
Fonction(f)
DEBUT
Si dizaine de millier=0
FAIRE AFFICHER " " et Fonction(e)
Si dizaine_de_millier=1
FAIRE AFFICHER "dix mille"
Si dizaine_de_millier=1 et Si millier=1
FAIRE AFFICHER "onze mille" et Fonction(e)
Si dizaine_de_millier=1 et Si millier=2
FAIRE AFFICHER "douze mille" et Fonction(e)
Si dizaine_de_millier=1 et Si millier=3
FAIRE AFFICHER "treize mille" et Fonction(e)
Si dizaine_de_millier=1 et Si millier=4
FAIRE AFFICHER "quatorze mille" et Fonction(e)
Si dizaine_de_millier=1 et Si millier=5
FAIRE AFFICHER "quinze mille" et Fonction(e)
Si dizaine_de_millier=1 et Si millier=6
FAIRE AFFICHER "seize mille" et Fonction(e)
Si dizaine_de_millier=1 et Si millier=7
FAIRE AFFICHER "dix sept mille" et Fonction(e)
Si dizaine_de_millier=1 et Si millier=8
FAIRE AFFICHER "dix huit mille" et Fonction(e)
Si dizaine_de_millier=1 et Si millier=9
FAIRE AFFICHER "dix neuf mille" et Fonction(e)
Si dizaine_de_millier=2
FAIRE AFFICHER "vingt mille" et Fonction(e)
Si dizaine_de_millier=3
FAIRE AFFICHER "trente mille" et Fonction(e)
Si dizaine_de_millier=4
FAIRE AFFICHER "quarante mille" et Fonction(e)
Si dizaine_de_millier=5
FAIRE AFFICHER "cinquante mille" et Fonction(e)
Si dizaine_de_millier=6
FAIRE AFFICHER "soixante mille" et Fonction(e)
Si dizaine_de_millier=7
FAIRE AFFICHER "soixante dix mille" et Fonction(e)
Si dizaine_de_millier=7 et Si millier=1
FAIRE AFFICHER "soixante et onze mille" et Fonction(e)
Si dizaine_de_millier=7 et Si millier=2
FAIRE AFFICHER "soixante douze mille" et Fonction(e)
Si dizaine_de_millier=7 et Si millier=3
FAIRE AFFICHER "soixante treize mille" et Fonction(e)
Si dizaine_de_millier=7 et Si millier=4
FAIRE AFFICHER "soixante quatorze mille" et Fonction(e)
Si dizaine_de_millier=7 et Si millier=5
FAIRE AFFICHER "soixante quinze mille" et Fonction(e)
Si dizaine_de_millier=7 et Si millier=6
FAIRE AFFICHER "soixante seize mille" et Fonction(e)
Si dizaine_de_millier=7 et Si millier=7
FAIRE AFFICHER "soixante dix sept mille" et Fonction(e)
Si dizaine_de_millier=7 et Si millier=8
FAIRE AFFICHER "soixante dix huit mille" et Fonction(e)
Si dizaine_de_millier=7 et Si millier=9
FAIRE AFFICHER "soixante dix neuf mille" et Fonction(e)
Si dizaine_de_millier=8
FAIRE AFFICHER "quatre vingt mille" et Fonction(e)
Si dizaine_de_millier=9
FAIRE AFFICHER "soixante dix mille" et Fonction(e)
Si dizaine_de_millier=9 et Si millier=1
FAIRE AFFICHER "quatre vingt onze mille" et Fonction(e)
Si dizaine_de_millier=9 et Si millier=2
FAIRE AFFICHER "quatre vingt douze mille" et Fonction(e)
Si dizaine_de_millier=9 et Si millier=3
FAIRE AFFICHER "quatre vingt treize mille" et Fonction(e)
Si dizaine_de_millier=9 et Si millier=4
FAIRE AFFICHER "quatre vingt quatorze mille" et Fonction(e)
Si dizaine_de_millier=9 et Si millier=5
FAIRE AFFICHER "quatre vingt quinze mille" et Fonction(e)
Si dizaine_de_millier=9 et Si millier=6
FAIRE AFFICHER "quatre vingt seize mille" et Fonction(e)
Si dizaine_de_millier=9 et Si millier=7
FAIRE AFFICHER "quatre vingt dix sept mille" et Fonction(e)
Si dizaine_de_millier=9 et Si millier=8
FAIRE AFFICHER "quatre vingt dix huit mille" et Fonction(e)
Si dizaine_de_millier=9 et Si millier=9
FAIRE AFFICHER "quatre vingt dix neuf mille" et Fonction(e)
FIN
 
fonction(g)
DEBUT
Si centaine_de_millier=0 
FAIRE AFFICHER " " et Fonction(f)
Si centaine_de_millier=1
FAIRE AFFICHER "cent mille" et Fonction(f)
Si centaine_de_millier=2
FAIRE AFFICHER "deux cent mille" et Fonction(f)
Si centaine_de_millier=3
FAIRE AFFICHER "trois cent mille" et Fonction(f)
Si centaine_de_millier=4
FAIRE AFFICHER "quatre cent mille" et Fonction(f)
Si centaine_de_millier=5
FAIRE AFFICHER "cinq cent mille" et Fonction(f)
Si centaine_de_millier=6
FAIRE AFFICHER "six cent mille" et Fonction(f)
Si centaine_de_millier=7
FAIRE AFFICHER "sept cent mille" et Fonction(f)
Si centaine_de_millier=8
FAIRE AFFICHER "huit cent mille" et Fonction(f)
Si centaine_de_millier=9
FAIRE AFFICHER "neuf cent mille" et Fonction(f)
FIN

[JeitEmgie]

Une solution générique qui permet de supporter assez facilement et très rapidement un grand nombre de langues différentes est :

1. avoir des tableaux dans lesquels on stocke les valeurs des chaînes pour les unités, dizaines, centaines et puissances de "millier" (million, milliard, etc) et pour les chaînes "spéciales" : les mots de liaison (par exemple le "et", le suffixe de pluriel s'il y en a un dans la langue...);
2. avoir pour la langue le nombre de digit des "milliers" et leurs puissances : si pour la plupart des langues occidentales le groupement est par 3, beaucoup de langues asiatiques groupent par 4 : ils diront "dix dix-mille" là où nous disons "cent mille" (càd qu'ils ont des mots pour dire "dix-mille", "cent-millions", ... là où nous avons "mille", "million", ...);
3. dans le cas général d'un montant on traite partie entière et décimale séparément : la routine de base ne s'occupe que de valeur entière;
4. la routine de base recevra donc un entier qu'elle convertira en chaîne en ajoutant devant autant de 0 que nécessaire pour obtenir une chaîne de N x le groupement correspondant à la longueur maximum du montant que l'on peut exprimer, par exemple en français si vous décidez de vous limitez aux milliards ce sera au maximum 12 caractères, donc pour une entrée de 12345 vous commencez avec 000000012345
cette routine de base va assembler selon les régles de grammaire de la langue les morceaux retournés par une sous-routine qui elle s'occupera des groupes de chiffres par taille du groupement en commençant par la droite (en fait on constate vite qu'il est plus facile d'inverser la chaîne de départ : donc dans notre exemple on assemblera les résultats retournés par les appels successifs à cette sous-routine pour "543", "210", ... - juste faire attention à ne pas sortir "zéro milliard zéro million douze mille...")
Cette sous-routine est alors assez triviale à écrire puisque le premier digit est celui des unités (donc on obtient trivialement son index dans le tableau de chaînes des "unités") le second celui des dizaines et le troisième celui des centaines...
Seules les régles de grammaire de la langue cible peuvent induire des variations pour la gestion des pluriels, là où il faut ou pas un espace ou un trait d'union entre les mots, les exceptions, ...
Et notez la gestion en groupe des unités et dizaines pour la plupart des langues germaniques (qui disent "un et vingt" pour 21...)
La routine de base elle assemblera les morceaux et saura évidemment à quel stade des unités, milliers, millions, milliards elle en est et ira dans le tableau adhoc chercher le bon mot et appliquera la régle de grammaire de la langue pour le pluriel éventuel.

Avec cette technique, n'importe quelle langue est supportée en environ une centaine de lignes de C, et encore : bien aéré.
(et tableau de chaînes en Unicode évidemment avec les routines C adaptées si vous voulez supporter les langues exotiques: pas de "strcat" and C°, cela va de soi)

(et pour le français n'oubliez pas les variations régionales : "septante", "octante" ou "huitante", "nonante" en Belgique et Suisse au lieu des "soixante-dix" et "quatre-vingt-dix" en France)

[diogene]

Ta méthode n'est pas bonne (sauf le principe du découpage en fonctions).
Par exemple, 384434 donnera :

fonction(g) -> affichage "trois cent mille" 
fonction(f) -> affichage "trois cent mille quatre vingt mille"
fonction(e) -> affichage "trois cent mille quatre vingt mille quatre mille"
fonction(d) -> affichage "trois cent mille quatre vingt mille quatre mille quatre cent"
fonction(c) -> affichage "trois cent mille quatre vingt mille quatre mille quatre cent trente"
fonction(a) -> affichage "trois cent mille quatre vingt mille quatre mille quatre cent trente quatre"

Alors que le principe de départ devrait être :

Pour afficher 384434 -> 384 et 434
afficher 384 -> "trois cent quatre-vingt-quatre"
afficher "mille"
afficher 434 -> "quatre cent trente-quatre" 

ce qui ramène le problème à savoir afficher les nombres entre 0 et 999. A noter que l'on doit prendre en compte à ce moment de l'exception sur le pluriel de vingt et cent : la manière d'écrire un nombre de 0 à 999 dépend si il s'agit des milliers ou non. Un exemple :

Pour afficher 380380 -> 380 et 380
afficher 380 -> "trois cent quatre-vingt" singulier de vingt puisqu'il sera suivi de "mille"
afficher "mille"
afficher 380 -> "trois cent quatre-vingts" pluriel de vingt puisqu'il n'est pas suivi de quelque chose

La fonction qui affiche les nombres de 0 à 999 doit pouvoir appliquer ou non la règle du pluriel de vingt et cent.

De la même façon, la méthode de base pour la fonction qui affiche les nombres de 0 à 999 est illustrée par l'exemple :

Pour afficher 384 -> 3 et 84
afficher 3
afficher "cent"
afficher 84

ce qui ramène le problème à savoir afficher les nombres entre 0 et 99

etc.

[jazzepa]

ah oui exact, il répète mille plusieurs fois, je suis complètement perdu du coup...
je ne vois plus comment il faut que je fasse...
mais de 0 à 999 c'est correct non ?

[Obsidian]

Hello,

ah oui exact, il répète mille plusieurs fois, je suis complètement perdu du coup...
je ne vois plus comment il faut que je fasse...

On te l'a expliqué plusieurs fois. Relis bien les commentaires.

Ton erreur est que tu raisonnes comme si tu voulais résoudre une opération arithmétique, ce qui en temps normal est une bonne chose mais qui n'est pas l'approche à suivre dans le cas présent. Ici, tu prends chaque poids « centaines de milliers, dizaine de milliers, milliers, centaines, dizaines et unités », puis tu les traites séparément en affichant individuellement leur valeur comme si tu voulais les cumuler.

En réalité, quand on énonce un nombre en français, on fait des groupes de trois chiffres, donc de 0 à 999, puis on applique éventuellement un coefficient multiplicateur, c'est-à-dire que l'on « alloue » une nouvelle tranche de trois chiffres : milliers, millions, ou milliards, ce qui permet de décaler respectivement ce nombre de une, deux ou trois fois trois chiffres. Quand on a besoin d'aller plus loin, on cumule ces mêmes coefficients : « milliers de millions, milliers de milliards, millions de milliards, … ».

On pourrait croire que la centaine est construite également de la même façon mais ce n'est pas tout-à-fait le cas : on ne peut pas les énumérer par dizaines : « cinquante-deux cent » (pour 5200) n'est pas correct. Ce n'est toléré que dans le langage courant et jusqu'à 19 seulement.

Ainsi, lorsque tu écris « 542456123 », tu obtiens :

— 542 millions ;
— 456 milliers ;
— 123 unités.

… que tu énonces donc en fait :

— 542 millions ;
— 456 mille ;
— 123.

Donc il faut d'un côté écrire une fonction qui écrit les nombres de 0 à 999 d'une manière générale puis utiliser cette fonction à bon escient selon les différentes tranches que tu as isolées.

mais de 0 à 999 c'est correct non ?

Il y a quelques petites erreurs : par exemple, tu as placé « neuf » dans la tranche des dizaines et tu pourrais factoriser également l'affichage des centaines : « deux cent; trois cent ; quatre cent ; … » … en affichant le chiffre (éventuellement à l'aide d'une fonction), puis en écrivant « cent » une fois pour toutes.

Et pour faire tout cela, tu pourrais même utiliser une seule fonction servant à tout faire, à condition qu'elle soit… récursive ! :-) Mais chut, je ne dis rien de tout cela pour le moment…