Ce qui est intéressant c'est de savoir laquelle de ces solutions est la plus rapide
- Méthode naive
- Méthode un peu meilleure
- Recherche de la meilleure méthode et application de cette méthode
salut
généralement ma méthode est utilisé pour un operateur
* qlq par exemple:
object X;
étant donné operateur * assez compliqué, on s'interressera
plutot à minimiser le nombre d'appel à l'operateur que minimiser le nombre de cases mémoire alouées.
c'est vrai pour le cas d'un operateur simple * pour les entiers ça parait inutile.
excuse moi,car j'ai pas eu le temps de déchiffrer les
<< ,le sizeof et les ! pour comprendre le but de ton code :)
ce que j'ai mis comme code c'est le code utilisé habituellement pour calculer une puissance entière
pour x^15 il fait
x2 = x*x
r = x*x2
x4 = x2*x2
r = r * x4
x8 = x4*x4
r = r * x8
--> 6 opérations, mais il n'utilise que 2 temporaires et là il y a une différence je pense, donc pourquoi ta façon est-elle meilleure (c'est ça que je n'ai pas étudié comme problème mais je suppose que toi oui) ?
salut,
d'abord on fait une recherche en profondeur pour trouver
toutes les operations minimum
ensuite on cherche à trouver la suite des multiplication
possible on fait une recherche en largeur car le nombre de
multiplication augmente de niveau en niveau.
Pour ACX01B je n'ai pas bien saisi ce que tu veut dire : tu veux dire que je dois utiliser des fonctions au lieu de blocs d'instructions ou que j'utilise des instructions complexe pour rien faire??
salut je n'ai pas vraiment regardé ton code mais qu'est-ce qui te dérange dans un code de ce type ???
#define SUPERPRINTF(X) printf(#X "= %d\n", X)
int puis(int a, unsigned int b) {
int l,i,x,r;
l = sizeof(unsigned int)*8-1;
while(!(b & (1<<l)) && l >= 0) l--;
x = a;
r = 1;
for (i = 0; i <= l; i++) {
if (b & (1<<i)) r *= x;
x *= x;
}
return r;
}
Rigolo, mais au final tu ne fais pas beaucoup plus d'opérations que ce qu'il y avait au départ ? :p
(oui je sais c'etait pas le but du programme)
Juste une question, c'est une recherche en largeur ou en profondeur que tu fais ? j'ai jamais trop saisi la différence en fait.
La ce que je vois, c'est que tu prends toutes les feuilles de ton arbre, et que tu en génère les successeurs (en virant les cas incompatibles/ceux qui ne resoudront jamais le probleme). Donc je dirais en profondeur. La largeur ce serait générer tous les successeurs d'un 'etage' en quelque sorte, puis pour tous les successeurs ainsi que ceux apparus générer les successeurs ...
Concrètement, quelle est la différence entre les 2 algorithmes ? (en termes de temps et de mémoire)
on peut chronométrer les threads ?
- Messages postés
-
6535
- Date d'inscription
- lundi 16 décembre 2002
- Statut
- Modérateur
- Dernière intervention
- 22 août 2010
7- Méthode naive
- Méthode un peu meilleure
- Recherche de la meilleure méthode et application de cette méthode
Tu as une idée?
généralement ma méthode est utilisé pour un operateur
* qlq par exemple:
object X;
étant donné operateur * assez compliqué, on s'interressera
plutot à minimiser le nombre d'appel à l'operateur que minimiser le nombre de cases mémoire alouées.
c'est vrai pour le cas d'un operateur simple * pour les entiers ça parait inutile.
excuse moi,car j'ai pas eu le temps de déchiffrer les
<< ,le sizeof et les ! pour comprendre le but de ton code :)
- Messages postés
-
280
- Date d'inscription
- dimanche 7 septembre 2003
- Statut
- Membre
- Dernière intervention
- 8 juillet 2014
4ce que j'ai mis comme code c'est le code utilisé habituellement pour calculer une puissance entière
pour x^15 il fait
x2 = x*x
r = x*x2
x4 = x2*x2
r = r * x4
x8 = x4*x4
r = r * x8
--> 6 opérations, mais il n'utilise que 2 temporaires et là il y a une différence je pense, donc pourquoi ta façon est-elle meilleure (c'est ça que je n'ai pas étudié comme problème mais je suppose que toi oui) ?