Affichage des nombre de 11 à19

Version imprimable

Bonjour,
j'ai développé un programme qui converti d'un chiffre écrit littéralement en un entier
le principe est de répartir des tableaux : unité, dizaine etc...

Code:

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
 
#include<stdio.h>
#include<string.h>
#include<conio.h>
 
 main()
{
char l1[50],l2[50],l3[50],l4[50], lettre[256];
char *espace = " ";
char unite[25][10]={"","un","deux","trois","quatre", "cinq", "six", "sept", "huit","neuf"};
char dizaine[11][20]={"","","vignt","trente","quarante","cinquante","soixante","soixante-dix","quatre-vignt","quatre-vignt-dix"};
char centaine[5][9]={"","cent","cents"};
int s,i,x1,x2,x3,x4;
strcpy(lettre,"");
printf("donner une chiffre literalement\n");
scanf("%s\n",&l1);
scanf("%s\n",&l2);
scanf("%s\n",&l3);
scanf("%s\n",&l4);
 
strcat(lettre,l1);
strcat(lettre,espace);
strcat(lettre,l2);
strcat(lettre,espace);
strcat(lettre,l3);
strcat(lettre,espace);
strcat(lettre,l4);
 
printf("%s\n",lettre);
 
for(i=0;i<10 || (strcmp(l1,unite[i])==0) ;i++)
if (strcmp(l1,unite[i])==0)
x1=i;
 
for(i=0;i<4 || (strcmp(l2,centaine[i])==0) ;i++)
if (strcmp(l2,centaine[i])==0)
x2=100;
 
for(i=0;i<11 || (strcmp(l3,dizaine[i])==0) ;i++)
if (strcmp(l3,dizaine[i])==0)
x3=10*i;
 
for(i=0;i<10 || (strcmp(l4,unite[i])==0) ;i++)
if (strcmp(l4,unite[i])==0)
x4=i;
 
printf(" ca fait :%d  ",x1*x2+x3+x4);
 
getch();
return 0;
}

jusqu'à maintenant tout est çava...sauf des nombre qui contient de chiffres de 11 à 19 commet 95 et 76 etc...
avez vous une idée pour afficher des nombre entre 11 et 19?
merci d'avance.

31/12/2009, 14h22
ok.Idriss
Salut.

Ce sujet récent pourra sans doute t'aider.

Sinon, idente ton code et autant utiliser getchar (); à la place de getch (); car il est standard et portable.

La syntaxe de main n'est pas correcte :
Code:

1 2 3 4 5 int main (void) { /* ... */ return 0; }
Edit : ah non, désolé, c'était toi l'auteur du sujet ... mais pourquoi changer de code ?
31/12/2009, 14h57
waldomania

ah t'a pas bien saisie mon mini projet est de convertir un entier en string et vise versa
ok pour le main ... en tout cas elle est comme ça temporairement parce que je le fusionnerai avec l'autre programme à la fin.
31/12/2009, 15h05
ok.Idriss

Ah d'accord autant pour moi désolé ... là c'est l'inverse du projet précédent.

Sinon ne met pas de séquences d'échappements dans tes scanf (je parle ici de \n). Ne met pas non plus de '&' dans les scanf qui saisissent des chaînes de carractères.

Tu peut simplifier comme ceci : scanf("%s %s %s %s",l1,l2,l3,l4);
31/12/2009, 15h19
Obsidian

Si tu veux convertir un nombre écrit de manière littérale en sa valeur numérique, le mieux est encore d'écrire la grammaire qui correspond. Je pense que cela ferait un très bon travail pratique de Lex & Yacc, si tu en as le courage.

En tout état de cause, il faut d'abord recenser tous les mots qui servent à décrire des nombres. Ça commence par « zéro » (même si, sous la forme littérale, on ne s'en sert que pour les nombres strictement compris entre -1 et 1), puis « un », « deux », « trois » … jusqu'à « dix », puis « onze », « douze » … jusqu'à « seize ». Ensuite, tu répertories les dizaines régulières « vingt », « trente », « quarante », etc. jusqu'à « soixante », pas plus loin. Ce sont là les seuls mots dont tu as besoin pour écrire tous les nombres jusqu'à 99. Après, tu ajoutes « cent », « mille », « million », « milliard », et éventuellement « plus », « moins » et « virgule » et tu peux alors gérer tous les nombres exprimables en français.

Étant donné que les nombres de 10 à 16 et de 80 à 99 sont des exceptions, il faut les gérer comme tels. Tu fais une sous-routine spéciale pour gérer les nombres de 1 à 19 et, d'autre part, tu fais en fais une autre pour détecter le « quatre-vingt ». Le cas échéant, tu rappelles la même sous-routine spéciale.

Attention enfin à l'orthographe de « vingt » dans ton programme, sinon tu risques de rencontrer des bugs assez pénibles à dénicher ! :mrgreen:
31/12/2009, 18h50
orfix

...sans oublier la conjonction «et», les traits d'union ainsi que les accords :mrgreen:

On peut s'amuser à faire ça avec le préprocesseur :aie:

Voilà un exemple (non complet) :

Code:

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
#include <stdio.h>
#include <stdlib.h>
 
#define LES_ZERO(nb)	\
	X( , 0, nb)			\
	X(un, 1, nb)		\
	X(deux, 2, nb)		\
	X(trois, 3, nb)		\
	X(quatre, 4, nb)	\
	X(cinq, 5, nb)		\
	X(six, 6, nb)		\
	X(sept, 7, nb)		\
	X(huit, 8, nb)		\
	X(neuf, 9, nb)
 
#define LES_DIX(nb)			\
	X11(dix, 10, nb)		\
	X11(onze, 11, nb)		\
	X11(douze, 12, nb)		\
	X11(treize, 13, nb)		\
	X11(quatorze, 14, nb)	\
	X11(quinze, 15, nb)		\
	X11(seize, 16, nb)		\
	X11(dix sept, 17, nb)	\
	X11(dix huit, 18, nb)	\
	X11(dix neuf, 19, nb)
 
#define LES_DIXAINES				\
	X10(vingt, 20, LES_ZERO)		\
	X10(trente, 30, LES_ZERO)		\
	X10(quarante, 40, LES_ZERO)		\
	X10(cinquante, 50, LES_ZERO)	\
	X10(soixante, 60, LES_ZERO)		\
	X10(soixante, 70, LES_DIX)		\
	X10(quatre vingt, 80, LES_ZERO)	\
	X10(quatre vingt, 90, LES_DIX)
 
char const * const tab[] = {
 
#define X(nb_lettre, nb_chiffres, nb)	#nb_lettre,
#define X11(nb_lettre, nb_chiffres, nb)	#nb_lettre,
 
	LES_ZERO(0)
	LES_DIX(0)
 
#undef X
#undef X11
 
#define X(nb_lettre, nb_chiffres, nb)	#nb " " #nb_lettre,
#define X11(nb_lettre, nb_chiffres, nb)	#nb " " #nb_lettre,
 
#define X10(nb_lettre, nb_chiffres, _)		\
	_(nb_lettre)
 
	LES_DIXAINES
};
 
int main(void) {
	int i;
	for (i = 0; i < 100; i++)
		printf("%s\n", tab[i]);
	return EXIT_SUCCESS;
}

Il ne gère pas le "et un" tous les traits d'union et compagnie mais l'idée est là :ccool:

01/01/2010, 09h52
waldomania

merci pour l'effort
01/01/2010, 13h43
Obsidian

Citation:

Envoyé par Pouet_forever

On peut s'amuser à faire ça avec le préprocesseur :aie:

Joli ! :bravo:

C'est l'opération inverse qui est plus difficile, toutefois…