[debutant]La décomposition arithmétique

**khedji** · 03/12/2006, 12h57

voila mon code j'ai utiliser une fonction recursive mais je compren pas ou est le bleme dans mon code :

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
#include<stdio.h>
#include<conio.c>
#include<math.h>
 
 unsigned dec(long n);
main()
 {
      long n;
      printf("donner votre chiffre:");
      scanf("%ld",&n);
      printf("%ld",dec(n));
  getch();
 }
 
 //definition de la focntion NB9
   unsigned dec(long n)
   {
            long a=pow(10,9),b=pow(10,6),c=pow(10,3),d=pow(10,2);
 
            if(n>=a)
             return (dec(n/a) *a  + dec(n%a));
 
             else
 
               if(n>=b)
                  return dec(n/b) * b  + dec(n%b);
               else
                  if(n>=c)
                     return dec(n/c) * c  + dec(n%c);
                 else
                     if(n>=d)
                       return dec(n/d) * d  + dec(n%d);
                     else
                       if (60<=n<100)
                         return dec(n/20) * 20 + dec(n%20);
                       else
                         if (10<=n<60)
                           return dec(n/10) * 10 + dec(n%10);    
                         else 
                          return n;
  }

et un grang merci d'vance

**Médinoc** · 03/12/2006, 13h13

Code plus ou moins corrigé et commenté.
Par contre, il plante toujours: Il y a un débordement de pile dans ta fonciton récursive. Et comme je ne connais pas ce qu'est la "décomposition arithmétique", je suis incapable de dire si oui ou non il y a une erreur dans ton algo...

Edit: Sur ma machine, ce n'est pas du à une erreur d'arrondi en tout cas: Je viens de tester les quatre long, il sont bien exactement égaux à 1 000 000 000, 1 000 000, 1 000 et 100.

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
#include <stdio.h>
#include <math.h>
 
unsigned dec(long n);
 
/* Fonction ajoutée pour purger convenablement stdin.
   Cette fonction purge la ligne courante de stdin 
   et s'arrête aussi si on tombe sur EOF.
   Elle peut aussi être utilisée pour attendre un appui sur ENTREE. */
void PurgeStream(FILE *pfIn)
{
	int c;
	while((c=fgetc(pfIn)) != '\n' && c != EOF)
	{}
}
 
/* Prototype de main() invalide. main() retourne TOUJOURS un int. */
int main(void)
{
	long n;
	int res;
	printf("donner votre chiffre:");
	/* fflush() est nécessaire si printf() ne se termine pas par \n. */
	fflush(stdout);
	/* Le retour de scanf() doit être vérifié, et il faut purger stdin après. */
	res = scanf("%ld",&n);
	PurgeStream(stdin);
	if(res == 1)
	{
		/* dec() retourne un unsigned int, donc %d suffit.
		   \n Ajouté. */
		printf("%d\n",dec(n));
	}
	else
		puts("Mauvais chiffre!");
 
	/* getch() n'est pas portable et inutile ici. 
	   On va juste demander de presser ENTREE. */
	printf("Presser [Entrée] pour quitter:");
	fflush(stdout);
	PurgeStream(stdin);
 
	/* main() retourne toujours un int. */
	return 0;
}
 
//definition de la focntion NB9
unsigned dec(long n)
{
	/* pow() retourne un nombre à virgule flottante.
	   Montrons qu'on force la conversion. */
	long a = (long)pow(10,9);
	long b = (long)pow(10,6);
	long c = (long)pow(10,3);
	long d = (long)pow(10,2);
 
	if(n>=a)
		return (dec(n/a) *a  + dec(n%a));
	else if(n>=b)
		return dec(n/b) * b  + dec(n%b);
	else if(n>=c)
		return dec(n/c) * c  + dec(n%c);
	else if(n>=d)
		return dec(n/d) * d  + dec(n%d);
	else if (60<=n<100)
		return dec(n/20) * 20 + dec(n%20);
	else if (10<=n<60)
		return dec(n/10) * 10 + dec(n%10);    
	else
	{
		/* Puisqu'on retourne un unsigned, 
		   autant montrer explicitement la conversion, 
		   surtout qu'on passe de long à int. */
		return (unsigned int)n;
	}
}

**khedji** · 03/12/2006, 13h56

17532=(10+7)*1000+5*100+30+2 c'est sa ce que je voulais faire

La décomposition arithmétique
dec(n) -->
si 10,9<=n dec(n/109) * 109 + dec(n%109)
dec(n) -->
si 10,6<=n dec(n/106) * 106 + dec(n%106)
dec(n) -->
si 10,3<=n dec(n/103) * 103 + dec(n%103)
dec(n) -->
si 10,2<=n dec(n/100) * 100 + dec(n%100)
dec(n) -->
si 60<=n<100 dec(n/20) * 20 + dec(n%20)
dec(n) -->
si 10<=n<60 dec(n/10) * 10 + dec(n%10)

10,i === pow(10,i)

**khedji** · 03/12/2006, 15h15

sa marche pas heuh !!!

**Médinoc** · 03/12/2006, 16h08

Envoyé par khedji

sa marche pas heuh !!!

C'est très mauvais, de dire ça.

Toutefois, j'ai trouvé où ça foirait, c'était dû à tes tests à la fin: tu ne peux pas écrire if(a<b<c) en C : Ça ne fait pas ce à quoi tu t'attends.

Code corrigé, avec des fonctions de débogage:
Si tu compiles avec -d _DEBUG sur la ligne de commande, ou si tu rajoutes #define _DEBUG au début du fichier, la fonction dec() indiquera ses différents appels récursifs... (et elle s'appellere dec_dbg() au lieu de dec(), d'ailleurs

)

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
#include <stdio.h>
#include <math.h>
 
#ifdef _DEBUG
	unsigned dec_dbg(long n, int indent);
	#define dec(x) dec_dbg((x), 0)
#else
	unsigned dec(long n);
#endif
 
/* Fonction ajoutée pour purger convenablement stdin.
   Cette fonction purge la ligne courante de stdin 
   et s'arrête aussi si on tombe sur EOF.
   Elle peut aussi être utilisée pour attendre un appui sur ENTREE. */
void PurgeStream(FILE *pfIn)
{
	int c;
	while((c=fgetc(pfIn)) != '\n' && c != EOF)
	{}
}
 
/* Prototype de main() invalide. main() retourne TOUJOURS un int. */
int main(void)
{
	long n;
	int res;
	printf("donner votre chiffre:");
	/* fflush() est nécessaire si printf() ne se termine pas par \n. */
	fflush(stdout);
	/* Le retour de scanf() doit être vérifié, et il faut purger stdin après. */
	res = scanf("%ld",&n);
	PurgeStream(stdin);
	if(res == 1)
	{
		/* dec() retourne un unsigned int, donc %d suffit.
		   \n Ajouté. */
		printf("%d\n", dec(n));
	}
	else
		puts("Mauvais chiffre!");
 
	/* getch() n'est pas portable et inutile ici. 
	   On va juste demander de presser ENTREE. */
	printf("Presser [Entree] pour quitter:");
	fflush(stdout);
	PurgeStream(stdin);
 
	/* main() retourne toujours un int. */
	return 0;
}
 
/* Fonction de débogage */
#ifdef _DEBUG
	#undef dec
	#define dec(x) dec_dbg(x, int indent)
#endif
 
//definition de la focntion NB9
unsigned dec(long n)
{
	#ifdef _DEBUG
		#undef dec
		#define dec(x) dec_dbg((x), indent+1)
	#endif
 
	static const long dix9 = 1000000000;
	static const long dix6 =    1000000;
	static const long dix3 =       1000;
	static const long dix2 =        100;
 
	#ifdef _DEBUG
	{
		int i;
		for(i=0 ; i<indent ; i++)
			putchar(' ');
		printf("dec(%ld)\n", n);
	}
	#endif
 
	if(n >= dix9)
		return dec(n/dix9) * dix9  +  dec(n%dix9);
	else if(n >= dix6)
		return dec(n/dix6) * dix6  +  dec(n%dix6);
	else if(n >= dix3)
		return dec(n/dix3) * dix3  +  dec(n%dix3);
	else if(n >= dix2)
		return dec(n/dix2) * dix2  +  dec(n%dix2);
	else if(n >= 60)
		return dec(n/20) * 20 + dec(n%20);
	else if (n >= 10)
		return dec(n/10) * 10 + dec(n%10);    
	else
	{
		/* Puisqu'on retourne un unsigned, 
		   autant montrer explicitement la conversion, 
		   surtout qu'on passe de long à int. */
		return (unsigned int)n;
	}
}

[debutant]La décomposition arithmétique

C

Discussions similaires

Partager

Partager