Programme factoriel en C: Comment calculer factoriel d'un nombre?

La factorielle d'un entier positif est le produit d'un entier et de tous les entiers en dessous. Apprenez à écrire un programme factoriel en C. Exemple: 3! = 3 * 2 * 1

La factorielle d'un entier positif est le produit d'un entier et de tous les entiers en dessous, c'est-à-dire que la factorielle du nombre n (représenté par n!) Serait donnée par



n! = 1 * 2 * 3 * 4 *. . . . . * n



types de transformation dans informatica

La factorielle de 0 est définie comme étant 1 et n'est pas définie pour les entiers négatifs. Il existe plusieurs façons de le trouver qui sont énumérées ci-dessous.

Commençons.



Factorielle utilisant la boucle For

C'est le moyen le plus simple et le plus simple de trouver la factorielle d'un nombre. Voyons d'abord le code -

#include int main () {int I, num, fact = 1 // définition factorielle comme 1 puisque la valeur minimale est 1 printf ('Entrez un nombre pour calculer sa factorielle') scanf ('% d', & num) if (num<0) //if the input is a negative integer { printf (“Factorial is not defined for negative numbers.”) } else { for(i=1i0, therefore fact value remains 1 { fact = fact * i // keeps on multiplying and storing in the value of factorial till the input integer is reached } printf(“Factorial of %d = %dn”, num, fact) } return 0 //since we have defined the main() method with a return value of integer type }

Production-

Factorielle de 5 = 120



Explication -

Le nombre dont la factorielle doit être trouvée est pris en entrée et stocké dans une variable et est vérifié s'il est négatif ou non. Si l'entier saisi est négatif, le message approprié s'affiche. La valeur de factorielle est prédéfinie à 1 car sa valeur minimale est 1. La boucle for est exécutée pour les entiers positifs (sauf pour 0 pour lequel la condition de test est fausse et donc le fait reste nul). Dans la boucle for, la valeur de factorielle est multipliée par chaque entier et stockée successivement jusqu'à ce que le nombre d'entrée soit atteint. Par exemple, pour input = 5, le flux va à la boucle for et les étapes suivantes ont lieu -

fait = 1, i = 1 -> fait = 1 * 1 = 1 -> i = 2
fait = 1, i = 2 -> fait = 1 * 2 = 2 -> i = 3
fait = 2, i = 3 -> fait = 2 * 3 = 6 -> i = 4
fait = 6, i = 4 -> fait = 6 * 4 = 24 -> i = 5
fait = 24, i = 5 -> fait = 24 * 5 = 120 -> i = 6

Maintenant 6> 5, donc la condition de test devient fausse et la boucle est terminée. La valeur factorielle est affichée.

Factorielle utilisant des fonctions

Cette approche est connue comme une approche modulaire et doit être suivie pour la programmation car elle est assez efficace. L'un de ses avantages est que lorsque nous devons apporter des modifications au code, au lieu de changer le code complet, nous pouvons simplement modifier la fonction concernée. Le code pour trouver la factorielle d'un nombre en utilisant cette approche est indiqué ci-dessous

#include long factorial (int num) // fonction de calcul factoriel qui prend une valeur entière comme paramètre et renvoie une valeur de type int {int i long fact = 1 for (i = 1 i<= num i++) fact = fact * i return fact //returns to function call } int main() //execution begins from main() method { int num printf('Enter a number to calculate its factorialn') scanf('%d', &num) if(num<0) //if the input is a negative integer { printf('Factorial is not defined for negative numbers.') } printf('Factorial of %d = %dn', num, factorial(num)) //call to factorial function passing the input as parameter return 0 } 

Production - Factorielle de 5 = 120

Explication-

La logique du programme est la même sauf qu'une fonction différente est utilisée pour calculer la factorielle et renvoyer la valeur à la méthode principale d'où commence l'exécution.

comment imprimer un tableau en php

Factorielle utilisant la récursivité

La récursivité est le processus dans lequel une fonction s'appelle elle-même et la fonction correspondante est appelée fonction récursive. Il se compose de deux parties: une condition de base et un appel récursif. La solution à la condition de base est fournie tandis que la solution à la valeur la plus élevée peut être résolue en convertissant en valeurs plus petites jusqu'à ce que la solution de base soit atteinte et utilisée.

Voici le code pour trouver des factorielles en utilisant la récursivité: -

#include int fact (int) // function prototype int main () {int num printf ('Entrez le nombre dont la factorielle doit être trouvée:') scanf ('% d', & num) if (num<0) { printf('ERROR. Factorial is not defined for negative integers') } printf('Factorial of %d is %d', num, fact(num)) //first call is made return 0 } int fact(int num) { if(num==0) //base condition { return 1 } else{ return(num*fact(num-1)) //recursive call } } 

Production - Factorielle de 5 = 120

Explication -Supposons que l'utilisateur entre 5 comme entrée, puis dans la méthode main () la valeur de num est 5. Au fur et à mesure que le flux passe dans l'instruction printf (ligne 12), un appel à la fonction fact (5) est effectué. Maintenant, pour fact (5) num est 5 qui n'est pas égal à 0, donc le flux va à l'instruction else où, dans l'instruction return, un appel récursif est effectué et fact (4) est effectué. Le processus est répété jusqu'à ce que la condition de base, c'est-à-dire que num = 0 soit atteinte et 1 soit renvoyé. Maintenant, le flux passe au fait (1) à partir duquel 1 (comme pour fact (1) num = 1) * 1 (la valeur renvoyée par fact (0)) est renvoyée. Ce processus est répété jusqu'à ce que la valeur requise soit obtenue.

Complexité temporelle et spatiale - Itération de récursivité V / S

Pour la récursivité

En ce qui concerne complexité temporelle , nous savons que le facteur 0 est la seule comparaison. Donc T (0) = 1. Pour la factorielle de tout autre nombre, le processus implique une comparaison, une multiplication, une soustraction et un appel de fonction. Donc

T (n) = T (n-1) +3
= T (n-2) +6
= T (n-3) +9
= & hellip.
= T (n-k) + 3k

quelles sont les contraintes dans sql

Puisque nous savons T (0) = 1 et pour k = n, (n-k) = 0

Donc T (n) = T (0) + 3n
= 1 + 3n

Par conséquent, la complexité temporelle du code est O (n).

En ce qui concerne complexité spatiale, une pile est créée pour chaque appel qui sera maintenue jusqu'à ce que sa valeur soitcalculé et renvoyé. Par exemple pour n = 5 les piles suivantes devront être maintenues

f (5) -> f (4) -> f (3) -> f (2) -> f (1) -> f (0)

Comme nous pouvons le voir, 5 piles devront être maintenues jusqu'à ce qu'un appel à f (0) soit atteint dont la valeur estconnu et est retourné. Par conséquent, pour n factorielle, n piles devront être maintenues. Ainsi complexité spatialeest sur). Il ressort également des images ci-dessus que pour n = 5, 5 piles devront êtreentretenu. Par conséquent, pour n factorielle, n piles devront être maintenues. Ainsi la complexité spatiale est O (n).

Pour itération-

En ce qui concerne complexité temporelle, il y a n itérations à l'intérieur de la boucle, donc la complexité temporelle est O (n).

En ce qui concerne complexité spatiale, pour une solution itérative, il n'y a qu'une seule pile qui doit être maintenue et une variable entière est utilisée. La complexité spatiale est donc O (1).

C’est tout pour cet article. J'espère que vous avez compris le concept du programme factoriel en C ainsi que les complexités temporelles.

Si vous rencontrez des questions, n'hésitez pas à poser toutes vos questions dans la section commentaires du «programme factoriel en C» et notre équipe se fera un plaisir de vous répondre.