Discussion :

[mekki_soft]

Bonjour,

Comment peut on écrire en c++ ce petit exercice svp ?
Merci

Voici l'exercice:
Si n impair
S= 1 !/x²+3!/x puissance 3 + ….. + n !/x puissance n
Si n pair
S=2 !/x²+4 !/x puissance4+……n !/x puissance n

[koala01]

Salut,

Tu n'as sans doute qu'une information manquante: comment savoir si un nombre est pair ou impair. Et, cela, c'est simple: tu regarde s'il est divisible par 2. Et comment tu peux le savoir grâce à ce que l'on appelle le modulo, qui calcule le reste de la division entre deux nombres. En C et en C++, modulo est représenté par le symbole %. si bien que si tu fais un test proche de if(nombre%2 == 0), tu sauras si ton nombre est pair ou impair

Le reste, c'est à toi de voir comment faire le calcul qui va bien

[ternel]

la puissance, c'est facile.
x puissance n, c'est 1 * x * x * ... avec n multiplication par x.

Par contre, la factorielle, ca va être plus comique.
Notamment, parce que par exemple, 20!, c'est 2 432 902 008 176 640 000 soit un peu plus que 2,4 milliards de milliards (ou 2,4 * 10^18)
C'est aussi a peu pres 2,4 * 2^60. Soit au moins 60 bits. Ca doit rentrer dans un long long (64 bits).
J'imagine qu'avec 23! on dépasse la représentation possible des entiers sur des ordinateurs (sans passer par des astuces monstrueusement lentes et hors de portée d'un tel exercice)

[JolyLoic]

Faire le calcul exact, effectivement, ça va vite bloquer. Maintenant, faire le calcul avec des doubles (voire des long double) donnera une valeur approchée pas forcément trop mauvaise. Bonne jusqu'à quel point, c'est une autre question, je ne sais pas trop, et ça dépend probablement très fortement de x. Pour des x positifs, ça devrait plutôt pas trop mal se passer par exemple.

[ternel]

Cela dit, n! / x^n, c'est le produit successif des i/x, pour i entre 1 et n.

[Gwynbleidd]

Bonsoir,
juste un conseil pour créer une fonction permettant de calculer une factorielle: je pense que tu devrais t'orienter vers une fonction récursive, pour faire simple, une fonction qui dans son code 'interne' s'appelle elle-même.
Cela devrait peut être te donner un axe de recherche.

Cordialement.

[koala01]

Surtout pas, malheureux!!!!

Il n'est absolument pas plus compliqué de créer une boucle qui puisse calculer la factorielle que de le faire de manière récursive. Et c'est ce que je reproche généralement à cet exemple.

Or, si tu peux t'en sortir avec une logique "assez simple" pour se contenter d'utiliser une boucle, tu n'as absolument aucun intérêt à envisager la récursivité, qui vient avec son lot de problème (dont, entres autres, un risque accru de dépassement de la capacité de la pile d'appels en C++).

Si tu te retrouves dans une situation dans laquelle il est plus difficile d'exprimer une logique au travers une boucle qu'au travers d'une fonction récursive (par exemple : la résolution des tours de Hanoï), alors, tu as tout intérêt à envisager la récursivité. Mais s'il est au moins aussi facile d'exprimer la logique au travers d'une boucle, tu as toujours intérêt à choisir la boucle "par défaut".

Le calcul d'une factorielle est, justement, ce genre de cas où il n'y a strictement aucune difficulté à exprimer la logique au travers d'une boucle. Donc, il est largement préférable d'utiliser une boucle

[Gwynbleidd]

Mea culpa dans ce cas !


Il est vrai que la solution apparente la plus simple n'est pas toujours la moins compliquée

Par contre pour le calcul de la factorielle avec une boucle: vous le feriez comme ça?

Code :

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

1
2
3
4
5
6
7
8
9
10
 
  int factorielle= 100; //on prend 100 comme 'exemple'
 
  int calcul_factorielle(int factorielle){
     int result=1;
     for(int i=factorielle; i>0; i--){
     result *=i;
     }
     return result;
  }

[prgasp77]

J'aoute mon grain de sel. Depuis C++11, std::tgamma a été ajouté à la bibliothèque standart.

Une implémentation de factorielle peut donc être :

Code :

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

1
2
3
4
5
#include <cmath>
long double factorial(long double n)
{
    return std::tgamma(n+1);
}