Discussion :

[candidson]

Bonjour,
je suis plus ou moins nouveau en C++ et j'ai un pti probleme. Comment pourrais-je calculer le % de facon iterative et sans utiliser les operateurs %, * et /.
Mon idée est la suivante:
Calcul de i%j:
i > j et j!=0;
calculer i - j et redonner le resultat juska ce ke i<j.
Mais je nariv pa à implementer i - j de facon periodique, cest a dire, i-j de facon repetee.

Voici ce ke g pu fair juska present:
Natural est la classe.

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
 
Natural operator%(Natural n1, Natural n2)
{
	int modulo(0);
	assert(n2.getValue()!=0);
	modulo = n1.getValue() - n2.getValue();
 
	if ( n1 == n2)
	{ return modulo = 0;}
	else	
		if(n1.getValue()<n2.getValue())
			{ return modulo =  n1.getValue();}
		else // c'est ici ke commencent les ennuis!!!
			{
				while (n1.getValue()>n2.getValue())
					return modulo = modulo - n2.getValue();
			}
 
 
			return modulo; 
}

Merci pour l'aide!

[jobherzt]

essaie d'utiliser la balise code, et si tu poste dans la rubrique algorithme, presente les choses sous la forme d'algorithme...

je ne suis pas un specialiste, mais le "return modulo=0", a mon avis ca ne va pas faire ce que tu veux.....

et on est bien content de savoir ou les ennuis commence, mais faudrait aussi preciser lesquelles meme si la c'est assez evident : pourquoi vient tu mettre un return au milieu de ta boucle ??? je te rappelle que return interrompt la fonction et retourne la valeur qui le suit. donc si tu vire tes return qui ne sont pas a leur place, ca devrait presque marcher...

sauf que "while (n1.getValue()>n2.getValue())" est toujours vrai puisque ces valeurs ne varient pas -> ca va tourner en rond. donc faut re-reflechir a ta boucle.

bon courage

[ol9245]

Code :

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

1
2
3
4
5
6
7
fonction modulo(entier : n, entier : modulo_m) : entier
vérifier n > 0 et modulo_m > 0
if n < modulo_m then
   return n
else
   return modulo (n - modulo_m, modulo_m)
end if

sinon, u peux exploiter que la division d'entier arrondit à l'entier inférieur ou égal le plus proche

Code :

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

1
2
fonction modulo(entier : n, entier : modulo_m) : entier
return n - (n/modulo_m) * modulo_m ;

[millie]

Code :

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

1
2
3
4
5
6
7
fonction modulo(entier : n, entier : modulo_m) : entier
vérifier n > 0 et modulo_m > 0
if n < modulo_m then
   return n
else
   return modulo (n - modulo_m, modulo_m)
end if

sinon, u peux exploiter que la division d'entier arrondit à l'entier inférieur ou égal le plus proche

Code :

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

1
2
fonction modulo(entier : n, entier : modulo_m) : entier
return n - (n/modulo_m) * modulo_m ;

J'ai une préférence pour la deuxième méthode qui a l'avantage d'être fait en temps "constant". La première méthode a une écriture récursive sympatique mais peut avoir tendance à être très long, rien que : 999999999999 % 1 risque de prend pas mal de temps

[jobherzt]

J'ai une préférence pour la deuxième méthode qui a l'avantage d'être fait en temps "constant". La première méthode a une écriture récursive sympatique mais peut avoir tendance à être très long, rien que : 999999999999 % 1 risque de prend pas mal de temps

il a indiqué qu'il n'avait pas le droit d'utiliser * et /

[millie]

il a indiqué qu'il n'avait pas le droit d'utiliser * et /

Honte à moi

Alors c'est facile, il suffit d'implémenter * en utilisant une méthode basée sur la transformée de Fourier rapide. Tu pourras ensuite faire une division à la manière classique, et le tour est joué

Bon, vu que c'est demandé de manière itérative et non récursive (et pas une méthode bourrine) :

le % de facon iterative

Un truc dans le genre devrait suffir (roh la la, j'ai beaucoup réflechi ) :

Code :

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

1
2
3
4
5
6
7
8
 
/*précondition : modulo_n >=1*/
fonction modulo(Entier n, Entier modulo_n)-> Entier
  Entier temp = n;
  while(temp>=modulo_n) 
     temp <- temp- modulo_n;
 
 return temp;