programmation de chiffres en lettres - Page 2

jazzepa · 09/02/2013, 10h16

ok merci beaucoup, donc je garde jusqu'a 999 (la simplification des centaine ce n'est pas grave, je n'ai plus trop de temps, j'ai encore le programme a faire)
donc après 1000 ca donnerait simplement :

DEBUT
Fonction(milliers)
Si n=1000
Faire afficher "mille" et Fonction(c)
Si n>1000
Faire afficher Fonction(c) et mille et Fonction(c)
FIN

diogene · 09/02/2013, 11h19

Cet algorithme est faux : tu dois au moins essayer de le faire tourner mentalement sur des exemples pour le confirmer un minimum. Dans ton cas si on a 1500 il va afficher "un mille...".
Il faut être plus attentif et ne pas y aller au pif. Tu perds un temps fou à procéder au hasard.

Il faut aussi être plus précis sur ta manière d'écrire un algorithme et notamment bien préciser sur quoi il s'applique.
Je te propose plutôt une formulation du genre:

//--------------------------------------------------
// L'algorithme FonctionMilliers affiche le nombre entier n , 0<= n <1000000
FonctionMilliers(n)                               
DEBUT
  SI n< 1000000 
      SI n>1999 FonctionCentaines(n/1000) 
      SI n>999   afficher "mille"    
      FonctionCentaines(n modulo(1000))   
FIN
//--------------------------------------------------

Comme il y a deux versions de l'affichage des centaines selon qu'on doit appliquer ou non la règle du pluriel de cent et vingt, on aura plutôt :

//--------------------------------------------------
// L'algorithme FonctionCentaines affiche le nombre entier n , 0<= n <1000.
// si mode = normal , en appliquant la règle du pluriel de vingt et cent
// si mode = singulier en gardant le singulier
//
FonctionCentaines(n, mode) 
DEBUT
...
FIN
//--------------------------------------------------
// L'algorithme FonctionMilliers affiche le nombre entier n , 0<= n <1000000
FonctionMilliers(n)                               
DEBUT
  SI n< 1000000 
     SI n>1999 FonctionCentaines(n/1000, singulier)
     SI n>999  afficher "mille"
     FonctionCentaines(n modulo(1000), normal)
FIN 
//--------------------------------------------------

jazzepa · 09/02/2013, 12h54

merci merci bien pour vos aides,

mais je ne comprend pas, pourquoi :
SI n>1999 FonctionCentaines(n/1000) ?

ah oui c'est bien mieux, je n'avais pas pensé à :
SI n>999 afficher "mille"
FonctionCentaines(n modulo(1000))

Joker-eph · 09/02/2013, 21h01

Si on est plus grand que "mille neuf cent quatre-vingt-dix-neuf", alors on commence à devoir dire quelques chose avant "mille". La division entière par 1000 revient à transformer "112458" en "112", et c'est bien "cent douze" qu'il faut afficher avant "mille".

jazzepa · 09/02/2013, 21h51

ah ok merci !
vraiment merci a tous pour votre aide sur l'algo, vous avez du me prendre pour un vrai nul mais c'est le cas mais au moins vous m'avez aidé et permis de comprendre donc merci beaucoup !!!!!!

j'ai fais le programme en c (j'espère qu'il n'y aura pas trop d'erreur...) et promis après je vous laisse tranquille c'est promis

!!!

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
uses crt,dos;
var
       a:integer;
       s:string;
  write('Entrer votre chiffre');
  read(s);
  val(s,g);
 
case s[1] of
'0':write('zero');
function tran(unite:integer):string;
      begin
if s[1]=1 then tran:='un';
if s[1]=2 then tran:='deux';
if s[1]=3 then tran:='trois';
if s[1]=4 then tran:='quatre';
if s[1]=5 then tran:='cinq';
if s[1]=6 then tran:='six';
if s[1]=7 then tran:='sept';
if s[1]=8 then tran:='huit';
if s[1]=9 then tran:='neuf';
end;
 
function tran(dizaine:integer):string;
      begin
if s[1]=0 then tran:='dix';
if s[1]=1 then tran:='onze';
if s[1]=2 then tran:='douze';
if s[1]=3 then tran:='treize';
if s[1]=4 then tran:='quartoze';
if s[1]=5 then tran:='quinze';
if s[1]=6 then tran:='seize';
if s[1]=7 then tran:='dix-sept';
if s[1]=8 then tran:='dix-huit';
if s[1]=9 then tran:='dix-neuf';
end;
 
function tran(a:integer):string;
      begin
if s[2]=0 then tran:=' ';
if s[2]=1 then tran:='et un';
if s[2]=2 then tran:='deux';
if s[2]=3 then tran:='trois';
if s[2]=4 then tran:='quatre';
if s[2]=5 then tran:='cinq';
if s[2]=6 then tran:='six';
if s[2]=7 then tran:='sept';
if s[2]=8 then tran:='huit';
if s[2]=9 then tran:='neuf';
end;
 
function tran(b:integer):string;
      begin
if s[1]=0 then tran:='dix';
if s[1]=1 then tran:='et onze';
if s[1]=2 then tran:='douze';
if s[1]=3 then tran:='treize';
if s[1]=4 then tran:='quartoze';
if s[1]=5 then tran:='quinze';
if s[1]=6 then tran:='seize';
if s[1]=7 then tran:='dix-sept';
if s[1]=8 then tran:='dix-huit';
if s[1]=9 then tran:='dix-neuf';
end;
 
function tran(c:integer):string;
begin
case s[1] of
'0':write(tran(unite));end;
'1';write(tran(dizaine));end;
'2':begin val(s[2],a);write('vingt ',tran(a));end;
'3':begin val(s[2],a);write('trente ',tran(a));end;
'4':begin val(s[2],a);write('quarante ',tran(a));end;
'5':begin val(s[2],a);write('cinquante ',tran(a));end;
'6':begin val(s[2],a);write('soixante ',tran(a));end;
'7':begin case s[2],b);write('soixante et 'tran(b);end;
'8':begin val(s[2],a);write('quatre vingt et ',tran(a));end;
'9':begin case s[2],b);write('quatre vingt 'tran(b);end;
end;
 
function tran(d:integer):string;
begin
case s[2] of
'0':write(tran(c));
'1':begin val(s[3],c);write('cent ',tran(c));end;
'2':begin val(s[3],c);write('deux cent ',tran(c));end;
'3':begin val(s[3],c);write('trois cent ',tran(c));end;
'4':begin val(s[3],c);write('quatre cent ',tran(c));end;
'5':begin val(s[3],c);write('cinq cent ',tran(c));end;
'6':begin val(s[3],c);write('six cent ',tran(c));end;
'7':begin val(s[3],c);write('sept cent ',tran(c));end;
'8':begin val(s[3],c);write('huit cent ',tran(c));end;
'9':begin val(s[3],c);write('neuf cent ',tran(c));end;
end;
 
function tran(e:integer):string;
case s[3] of
if s[4]=1 then tran:='mille';
if s[4]>1 or s[5]>=0 ou s[6]>=0 then write(tran(c), 'mille',tran(c));end;
end;
 
function tran(milliers:integer):string;
begin
if n< 1000000;
if n>1999 write(tran(c(s/1000);
if n>999 tran:='mille';    
function tran(c(n - 1000(n/1000)));
end;

pour le n modulo 1000 j'ai trouvé la forme sur internet parce que comme vous l'avez compris je ne suis pas très bon dans la prog...

Joker-eph · 09/02/2013, 22h27

Quand tu postes, si tu peux mettre le code entre balise "[code]" ça aide à lire.
(Et ce que tu as posté n'est pas du C)

Obsidian · 09/02/2013, 22h51

Bonsoir,

Citation:

Envoyé par jazzepa

j'ai fais le programme en c (j'espère qu'il n'y aura pas trop d'erreur...) et promis après je vous laisse tranquille c'est promis

!!!

À première vue, ce n'est malheureusement pas du C :-( Ça ressemble plus à une sorte de Pascal.

jazzepa · 09/02/2013, 23h08

ah mince, merci, bon ba je vais repotassé mon programme pour avoir du c...

jazzepa · 10/02/2013, 11h31

Je bloque, comment on fait pour traduire ça en c :

Code :

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

1
2
3
4
function tran(a:integer):string;
      begin
if s[2]=1 then tran:='et un';
end

et :

Code :

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

'1':begin val(s[3],c);write('cent ',tran(c));end;

Obsidian · 10/02/2013, 13h35

Si « tran » est le nom de ta fonction, alors :

Citation:

Envoyé par jazzepa

je bloque, comment on fait pour traduire ca en c :
function tran(a:integer):string;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part
    char const * tran(int a)

… soit le nom de la fonction immédiatement suivi par ses parenthèses (avec des espaces éventuels quand même) et précédé par son type comme pour n'importe quelle variable. Le type d'une fonction correspond donc au type de la valeur qu'elle va retourner.

Il n'y a malheureusement pas de type « string » en C. La manière normale des les manipulers en C consiste à utiliser un pointeur vers un char, et plus précisément le premier des caractères de la chaîne à transmettre, laquelle doit se terminer par un caractère nul « '\0' » (code ASCII 00) pour qu'on puisse en détecter la fin. Ce caractère est automatiquement ajouté lorsque tu définis des chaînes constantes avec les guillemets « " " » et quand tu utilises les fonctions standard de manipulation des chaînes.

Ça veut dire que tu peux facilement échanger des chaînes de caractères toutes faites mais qu'il est plus difficile de les modifier et/ou de changer leur taille.

Citation:

begin
…
end

se traduit en

Code :

Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
{
    …
}

On utilise beaucoup les blocs entre accolades en C. Ils sont parfois facultatifs mais toujours nécessaires pour contenir le code d'une fonction.

jazzepa · 10/02/2013, 14h37

ok, merci, mais comment on fait pour utilisé les chiffres de la 2eme colonne, on est obligé de passé par des matrices ou on peut directement appelé la 2eme colonne ?

Obsidian · 10/02/2013, 14h57

Citation:

Envoyé par jazzepa

ok, merci, mais comment on fait pour utilisé les chiffres de la 2eme colonne, on est obligé de passé par des matrices ou on peut directement appelé la 2eme colonne ?

Si par « 2ème » colonne, tu entends « deuxième caractère » de la chaîne, alors un chaîne de caractères est en fait un tableau de caractères : tu peux donc directement indexer ce tableau pour lire le caractère qui t'intéresse. Par exemple « s[1] » pour lire le second caractère. Ne pas oublier que l'indice d'un tableau est un offset par rapport à son début et qu'à ce titre, il commence donc à zéro ;
Si tu veux dire en fait « le deuxième mot », il n'y a pas de manière de faire cela directement : il faut passer par des fonctions faite pour ;
Si tu veux dire « la colonne des dizaines, des centaines, des unités, etc. », ce n'est de toutes façons pas au niveau des tableaux et encore moins à celui des chaînes de caractères qu'il faut travailler : c'est-à-toi de réduire ton entier numérique à la portion qui t'intéresse en utilisant des divisions et des modules (et éventuellement des décalages et des masques de bits lorsque tu travailles sur des puissances de 2 et que tu as l'habitude du binaire).

En l'occurrence, tu peux écrire ton programme sans jamais avoir besoin de retourner une chaîne de caractère. À dire vrai, ta fonction pourrait même ne jamais rien retourner du tout, et être une procédure en Pascal. Les seules chaînes que tu as à manipuler sont celles que tu envoies vers l'écran directement.

jazzepa · 10/02/2013, 15h41

OK, donc ça donne ça :

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
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
#include<stdio.h>
 
char const * unite(int nb)
{
 void nb_unite (int nb)
 {
  switch (nb)
  {
    case 0:
      printf("zero");
      break;
    case 1:
      printf("un");
      break;
    case 2:
      printf("deux");
      break;
    case 3:
      printf("trois");
      break;
    case 4:
      printf("quatre");
      break;
    case 5:
      printf("cinq");
      break;
    case 6:
      printf("six");
      break;
    case 7:
      printf("sept");
      break;
    case 8:
      printf("huit");
      break;
    case 9:
      printf("neuf");
      break;
  }
 }
}
 
 
char const * dizaine(int nb)
{
 void nb_dizaine (int nb)
 {
  switch (nb)
  {
    case 10:
      printf("dix");
      break;
    case 11:
      printf("onze");
      break;
    case 12:
      printf("douze");
      break;
    case 13:
      printf("treize");
      break;
    case 14:
      printf("quatorze");
      break;
    case 15:
      printf("quinze");
      break;
    case 16:
      printf("seize");
      break;
    case 17:
      printf("dix-sept");
      break;
    case 18:
      printf("dix-huit");
      break;
    case 19:
      printf("dix-neuf");
      break;
  }
 }
}
 
 
char const * a(int nb)
{
 void nb_unite (int nb)
 {
  switch (nb)
  {
    case s[2]=0:
      printf("'\0'");
      break;
    case s[2]=1:
      printf("et un");
      break;
    case s[2]=2:
      printf("deux");
      break;
    case s[2]=3:
      printf("trois");
      break;
    case s[2]=4:
      printf("quatre");
      break;
    case s[2]=5:
      printf("cinq");
      break;
    case s[2]=6:
      printf("six");
      break;
    case s[2]=7:
      printf("sept");
      break;
    case s[2]=8:
      printf("huit");
      break;
    case s[2]=9:
      printf("neuf");
      break;
  }
 }
}
 
 
char const * b(int nb)
{
 void nb_b (int nb)
 {
  switch (nb)
  {
    case s[1]=0:
      printf("dix");
      break;
    case s[1]=1:
      printf("et onze");
      break;
    case s[1]=2:
      printf("douze");
      break;
    case s[1]=3:
      printf("treize");
      break;
    case s[1]=4:
      printf("quatorze");
      break;
    case s[1]=5:
      printf("quinze");
      break;
    case s[1]=6:
      printf("seize");
      break;
    case s[1]=7:
      printf("dix-sept");
      break;
    case s[1]=8:
      printf("dix-huit");
      break;
    case s[1]=9:
      printf("dix-neuf");
      break;
  }
 }
}
 
 
char const * c(int nb)
{
 void nb_c (int nb)
 {
  switch (nb)
  {
    case s[2]=0:
      printf(char const * unite);
      break;
    case s[2]=1:
      printf(char const * dizaine);
      break;
    case s[2]=2:
      printf("vingt" and const * a);
      break;
    case s[2]=3:
      printf("trente" and const * a);
      break;
    case s[2]=4:
      printf("quarante" and const * a);
      break;
    case s[2]=5:
      printf("cinquante" and const * a);
      break;
    case s[2]=6:
      printf("soixante" and const * a);
      break;
    case s[2]=7:
      printf("soixante dix" and const * b);
      break;
    case s[2]=8:
      printf("quatre vingt" and const * a);
      break;
    case s[2]=9:
      printf("quatre vingt dix" and const * b);
      break;
  }
 }
}
 
 
char const * d(int nb)
{
 void nb_d (int nb)
 {
  switch (nb)
  {
    case s[3]=0:
      printf(char const * c);
      break;
    case s[3]=1:
      printf(char const * c);
      break;
    case s[3]=2:
      printf("deux cent" and const * c);
      break;
    case s[3]=3:
      printf("trois cent" and const * c);
      break;
    case s[3]=4:
      printf("quatre cent" and const * c);
      break;
    case s[3]=5:
      printf("cinq cent" and const * c);
      break;
    case s[3]=6:
      printf("six cent" and const * c);
      break;
    case s[3]=7:
      printf("sept cent" and const * c);
      break;
    case s[3]=8:
      printf("huit cent" and const * c);
      break;
    case s[3]=9:
      printf("neuf cent" and const * c);
      break;
  }
 }
}
 
 
char const * e(int nb)
{
 void nb_e (int nb)
 {
  switch (nb)
  {
   s[3] of
   if s[4]=1 pritf('mille');
   if s[4]>1 or s[5]>=0 ou s[6]>=0 printf(char const * c and 'mille' and char const * c;
  }
 }
}
 
 
char const * milliers(int nb)
{
 void nb_e (int nb)
 {
  switch (nb)
  {
if n< 1000000;
if n>1999 printf(char const * milliers(char const * c(s/1000);
if n>999 printf('mille');    
char const * c(n - 1000(n/1000));
  }
 }
}
 
 
int main()
{
  int x;
  printf ("Introduire un chiffre");
  scanf ("%d", &x); 
  nb_20 (x);
  return 0;
}

mais ce n'est pas comme ça que l'on fait pour appeler les fonctions ?

Kirilenko · 10/02/2013, 16h19

Bonjour,

Les fonctions imbriquées en C, ce n'est pas standard, et les implémentations sont généralement assez foireuses (pile exécutable, trampolines, etc.). Donc, à moins de savoir ce que tu fais, il vaut mieux éviter. Surtout que là, ça vient sûrement d'une absence de compréhension du fonctionnement de la fonction. return est sans doute ce que tu cherches... Enfin, je pense qu'il vaut mieux que tu relises un cours de C à tête reposée.

Bonne journée !

jazzepa · 11/02/2013, 12h09

J'aimerais que vous me disiez exactement ce qui ne va pas et pourquoi ca ne va pas et comment rectifier les erreurs de mon programme car me dire de revoir mes cours ca ne m'avance pas beaucoup...

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
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
 
#include<stdio.h>
 
char const * unite(int unite)
{
 void unite (int unite)
 {
  switch (unite)
  {
    case 0:
      printf("zero");
      break;
    case 1:
      printf("un");
      break;
    case 2:
      printf("deux");
      break;
    case 3:
      printf("trois");
      break;
    case 4:
      printf("quatre");
      break;
    case 5:
      printf("cinq");
      break;
    case 6:
      printf("six");
      break;
    case 7:
      printf("sept");
      break;
    case 8:
      printf("huit");
      break;
    case 9:
      printf("neuf");
      break;
  }
 }
}
 
 
char const * dizaine(int dizaine)
{
 void dizaine (int dizaine)
 {
  switch (dizaine)
  {
    case 10:
      printf("dix");
      break;
    case 11:
      printf("onze");
      break;
    case 12:
      printf("douze");
      break;
    case 13:
      printf("treize");
      break;
    case 14:
      printf("quatorze");
      break;
    case 15:
      printf("quinze");
      break;
    case 16:
      printf("seize");
      break;
    case 17:
      printf("dix-sept");
      break;
    case 18:
      printf("dix-huit");
      break;
    case 19:
      printf("dix-neuf");
      break;
  }
 }
}
 
 
char const * a(int a)
{
 void a (int a)
 {
  switch (a)
  {
    case s[2]=0:
      printf("'\0'");
      break;
    case s[2]=1:
      printf("et un");
      break;
    case s[2]=2:
      printf("deux");
      break;
    case s[2]=3:
      printf("trois");
      break;
    case s[2]=4:
      printf("quatre");
      break;
    case s[2]=5:
      printf("cinq");
      break;
    case s[2]=6:
      printf("six");
      break;
    case s[2]=7:
      printf("sept");
      break;
    case s[2]=8:
      printf("huit");
      break;
    case s[2]=9:
      printf("neuf");
      break;
  }
 }
}
 
 
char const * b(int b)
{
 void b (int b)
 {
  switch (b)
  {
    case s[1]=0:
      printf("dix");
      break;
    case s[1]=1:
      printf("et onze");
      break;
    case s[1]=2:
      printf("douze");
      break;
    case s[1]=3:
      printf("treize");
      break;
    case s[1]=4:
      printf("quatorze");
      break;
    case s[1]=5:
      printf("quinze");
      break;
    case s[1]=6:
      printf("seize");
      break;
    case s[1]=7:
      printf("dix-sept");
      break;
    case s[1]=8:
      printf("dix-huit");
      break;
    case s[1]=9:
      printf("dix-neuf");
      break;
  }
 }
}
 
 
char const * c(int c)
{
 void c (int c)
 {
  switch (c)
  {
    case s[2]=0:
      printf(char const * unite);
      break;
    case s[2]=1:
      printf(char const * dizaine);
      break;
    case s[2]=2:
      printf("vingt" and const * a);
      break;
    case s[2]=3:
      printf("trente" and const * a);
      break;
    case s[2]=4:
      printf("quarante" and const * a);
      break;
    case s[2]=5:
      printf("cinquante" and const * a);
      break;
    case s[2]=6:
      printf("soixante" and const * a);
      break;
    case s[2]=7:
      printf("soixante dix" and const * b);
      break;
    case s[2]=8:
      printf("quatre vingt" and const * a);
      break;
    case s[2]=9:
      printf("quatre vingt dix" and const * b);
      break;
  }
 }
}
 
 
char const * d(int d)
{
 void d (int d)
 {
  switch (d)
  {
    case s[3]=0:
      printf(char const * c);
      break;
    case s[3]=1:
      printf(char const * c);
      break;
    case s[3]=2:
      printf("deux cent" and const * c);
      break;
    case s[3]=3:
      printf("trois cent" and const * c);
      break;
    case s[3]=4:
      printf("quatre cent" and const * c);
      break;
    case s[3]=5:
      printf("cinq cent" and const * c);
      break;
    case s[3]=6:
      printf("six cent" and const * c);
      break;
    case s[3]=7:
      printf("sept cent" and const * c);
      break;
    case s[3]=8:
      printf("huit cent" and const * c);
      break;
    case s[3]=9:
      printf("neuf cent" and const * c);
      break;
  }
 }
}
 
 
char const * e(int e)
{
 void e (int e)
 {
  switch (nb)
  {
   s[3] of
   if s[4]=1 pritf('mille');
   if s[4]>1 or s[5]>=0 ou s[6]>=0 printf(char const * c and 'mille' and char const * c;
  }
 }
}
 
 
char const * milliers(int milliers)
{
 void e (int e)
 {
  switch (e)
  {
if (n< 1000000 && n>1999) printf(char const * milliers(char const * c(s/1000);
if n>999 printf('mille');    
char const * c(n - 1000(n/1000));
  }
 }
}
 
 
int main()
{
  int x;
  printf ("Introduire un chiffre");
  scanf ("%d", &x); 
  nb_20 (x);
  return 0;
}

diogene · 11/02/2013, 12h28

Code :

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

1
2
3
4
char const * unite(int unite)
{
 void unite (int unite)
 {...

Ceci constitue une définition de fonction (void unite (int unite)) à l'intérieur de la définition d'une fonction (char const * unite(int unite)) ce qui est illégal en C standard (mais légal en Pascal).
La fonction ne renvoie rien donc son type de retour est void, pas char const *.

Sur ce genre de fonctions, au lieu d'un switch, il est avantageux d'utiliser un tableau :

Code :

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

1
2
3
4
5
void unite(int unite)
{
   static char const * Tab[] = { "zero", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf"};
   if(unite >=0 && unite <10) printf("%s", Tab[unite]);
}

Ces remarques sont valables pour les autres fonctions.

Citation:

car me dire de revoir mes cours ca ne m'avance pas beaucoup...

Mais cela semble indispensable. Il te manque le B.A BA du C

jazzepa · 11/02/2013, 13h52

ok, merci, c'est plus clair mais ce qui est très difficil c'est de savoir quoi utiliser (le " static char const")
ah daccor on n'a pas le droit d'écrire un fonction dans une autre en C...

donc pour les reste c'est :

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
 
void d (int d)
{
if(s[3] =0) prinf("%s", Tab[c]);
   static char const * Tab[] = { "cent", "deux cent", "trois cent", "quatre cent", "cinq cent", "six cent", "sept cent", "huit cent", "neuf cent"};
   if(s[3] >=1 && s[3]<10) printf("%s", Tab[d] && Tac[c]);
}
 
void e (int e)
{
s[3] of
   if s[4]=1 pritf("%s", 'mille' && Tab[d]);
   if s[4]>1 or s[5]>=0 ou s[6]>=0 printf(Tab[c] && 'mille' && Tab[c]);
}
 
Void milliers(int milliers)
{
if (n <1000000 && n >1999) printf(char const * milliers(char const * c(n/1000);
if (n >999) printf('mille' && Tab[c](n - 1000(n/1000));
}
 
 
int main()
{
  int x;
  printf ("Introduire un chiffre");
  scanf ("%d", &x); 
  nb_20 (x);
  return 0;
}

diogene · 11/02/2013, 13h59

Code :

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

1
2
3
4
5
void d (int d)
{
if(s[3] =0) prinf("%s", Tab[c]);
...
}

Qu'est-ce que c'est que ce s[3], ce c et ce Tab qui ne sont pas définis ?

09/02/2013, 11h19	#22
diogene Responsable Modération Patrick Gonord Enseignant Chercheur Inscription : juin 2005 Messages : 5 434 Détails du profil Informations personnelles : Nom : Patrick Gonord Localisation : France, Essonne (Île de France) Informations professionnelles : Activité : Enseignant Chercheur Secteur : Enseignement Informations forums : Inscription : juin 2005 Messages : 5 434 Points : 12 955 Points : 12 955	Cet algorithme est faux : tu dois au moins essayer de le faire tourner mentalement sur des exemples pour le confirmer un minimum. Dans ton cas si on a 1500 il va afficher "un mille...". Il faut être plus attentif et ne pas y aller au pif. Tu perds un temps fou à procéder au hasard. Il faut aussi être plus précis sur ta manière d'écrire un algorithme et notamment bien préciser sur quoi il s'applique. Je te propose plutôt une formulation du genre: //-------------------------------------------------- // L'algorithme FonctionMilliers affiche le nombre entier n , 0<= n <1000000 FonctionMilliers(n) DEBUT SI n< 1000000 SI n>1999 FonctionCentaines(n/1000) SI n>999 afficher "mille" FonctionCentaines(n modulo(1000)) FIN //-------------------------------------------------- Comme il y a deux versions de l'affichage des centaines selon qu'on doit appliquer ou non la règle du pluriel de cent et vingt, on aura plutôt : //-------------------------------------------------- // L'algorithme FonctionCentaines affiche le nombre entier n , 0<= n <1000. // si mode = normal , en appliquant la règle du pluriel de vingt et cent // si mode = singulier en gardant le singulier // FonctionCentaines(n, mode) DEBUT ... FIN //-------------------------------------------------- // L'algorithme FonctionMilliers affiche le nombre entier n , 0<= n <1000000 FonctionMilliers(n) DEBUT SI n< 1000000 SI n>1999 FonctionCentaines(n/1000, singulier) SI n>999 afficher "mille" FonctionCentaines(n modulo(1000), normal) FIN //-------------------------------------------------- __________________ Publication : Concepts en C Mon avatar : Glenn Gould -------------------------------------------------------------------------- Une réponse vous a été utile ? Remerciez son auteur en cliquant le pouce vert !
	30

10/02/2013, 16h19	#34
Kirilenko Membre émérite Lucas Pesenti Étudiant Inscription : décembre 2011 Messages : 234 Détails du profil Informations personnelles : Nom : Lucas Pesenti Âge : 16 Localisation : France, Vaucluse (Provence Alpes Côte d'Azur) Informations professionnelles : Activité : Étudiant Secteur : High Tech - Éditeur de logiciels Informations forums : Inscription : décembre 2011 Messages : 234 Points : 859 Points : 859	Bonjour, Les fonctions imbriquées en C, ce n'est pas standard, et les implémentations sont généralement assez foireuses (pile exécutable, trampolines, etc.). Donc, à moins de savoir ce que tu fais, il vaut mieux éviter. Surtout que là, ça vient sûrement d'une absence de compréhension du fonctionnement de la fonction. return est sans doute ce que tu cherches... Enfin, je pense qu'il vaut mieux que tu relises un cours de C à tête reposée. Bonne journée ! __________________ Récursivité en C : épidémie ou hérésie ? "Pour être un saint dans l'Église de l'Emacs, il faut vivre une vie pure. Il faut se passer de tout logiciel propriétaire. Heureusement, être célibataire n'est pas obligé. C'est donc bien mieux que les autres églises" - Richard Stallman
	20

09/02/2013, 10h16	#21
jazzepa Étudiant Inscription : février 2013 Messages : 15 Détails du profil Informations personnelles : Sexe : Localisation : France Informations professionnelles : Activité : Étudiant Informations forums : Inscription : février 2013 Messages : 15 Points : -2 Points : -2	ok merci beaucoup, donc je garde jusqu'a 999 (la simplification des centaine ce n'est pas grave, je n'ai plus trop de temps, j'ai encore le programme a faire) donc après 1000 ca donnerait simplement : DEBUT Fonction(milliers) Si n=1000 Faire afficher "mille" et Fonction(c) Si n>1000 Faire afficher Fonction(c) et mille et Fonction(c) FIN
	00

09/02/2013, 12h54	#23
jazzepa Étudiant Inscription : février 2013 Messages : 15 Détails du profil Informations personnelles : Sexe : Localisation : France Informations professionnelles : Activité : Étudiant Informations forums : Inscription : février 2013 Messages : 15 Points : -2 Points : -2	merci merci bien pour vos aides, mais je ne comprend pas, pourquoi : SI n>1999 FonctionCentaines(n/1000) ? ah oui c'est bien mieux, je n'avais pas pensé à : SI n>999 afficher "mille" FonctionCentaines(n modulo(1000))
	00

09/02/2013, 21h01	#24
Joker-eph Membre expérimenté Inscription : octobre 2004 Messages : 329 Détails du profil Informations forums : Inscription : octobre 2004 Messages : 329 Points : 528 Points : 528	Si on est plus grand que "mille neuf cent quatre-vingt-dix-neuf", alors on commence à devoir dire quelques chose avant "mille". La division entière par 1000 revient à transformer "112458" en "112", et c'est bien "cent douze" qu'il faut afficher avant "mille".
	00

09/02/2013, 22h27	#26
Joker-eph Membre expérimenté Inscription : octobre 2004 Messages : 329 Détails du profil Informations forums : Inscription : octobre 2004 Messages : 329 Points : 528 Points : 528	Quand tu postes, si tu peux mettre le code entre balise "[code]" ça aide à lire. (Et ce que tu as posté n'est pas du C)
	00

09/02/2013, 23h08	#28
jazzepa Étudiant Inscription : février 2013 Messages : 15 Détails du profil Informations personnelles : Sexe : Localisation : France Informations professionnelles : Activité : Étudiant Informations forums : Inscription : février 2013 Messages : 15 Points : -2 Points : -2	ah mince, merci, bon ba je vais repotassé mon programme pour avoir du c...
	00

10/02/2013, 14h37	#31
jazzepa Étudiant Inscription : février 2013 Messages : 15 Détails du profil Informations personnelles : Sexe : Localisation : France Informations professionnelles : Activité : Étudiant Informations forums : Inscription : février 2013 Messages : 15 Points : -2 Points : -2	ok, merci, mais comment on fait pour utilisé les chiffres de la 2eme colonne, on est obligé de passé par des matrices ou on peut directement appelé la 2eme colonne ?
	00

Outils de la discussion
Afficher une version imprimable Envoyer un lien vers cette page par email