Fattoriale di un numero intero positivo è il prodotto di un intero e tutti gli interi sottostanti, cioè il fattoriale del numero n (rappresentato da n!) Sarebbe dato da
n! = 1 * 2 * 3 * 4 *. . . . . * n
Il fattoriale di 0 è definito come 1 e non è definito per interi negativi. Esistono diversi modi per trovarlo elencati di seguito:
cos'è un evento javascript
- Programma fattoriale in Cutilizzando il ciclo For
- Programma fattoriale utilizzandoFunzioni
- Programma fattorialeutilizzando la ricorsione
Iniziamo.
Fattoriale utilizzando For Loop
È il modo più semplice e semplice per trovare il fattoriale di un numero. Visitiamo prima il codice -
#include int main () {int I, num, fact = 1 // definisce fattoriale come 1 poiché il valore minimo è 1 printf ('Inserisci un numero per calcolare il suo fattoriale') 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 }Produzione-
Fattoriale di 5 = 120
Spiegazione -
Il numero di cui si vuole trovare il fattoriale viene preso come input e memorizzato in una variabile e viene controllato se è negativo o meno. Se il numero intero inserito è negativo, viene visualizzato il messaggio appropriato. Il valore del fattoriale è predefinito come 1 poiché il suo valore minimo è 1. Il ciclo for viene eseguito per interi positivi (tranne per 0 per cui la condizione di test è falsa e quindi il fatto rimane zero). Nel ciclo for, il valore del fattoriale viene moltiplicato per ogni numero intero e memorizzato successivamente fino a raggiungere il numero di input. Ad esempio, per input = 5, il flusso passa al ciclo for e vengono eseguiti i seguenti passaggi:
fatto = 1, i = 1 -> fatto = 1 * 1 = 1 -> i = 2
fatto = 1, i = 2 -> fatto = 1 * 2 = 2 -> i = 3
fatto = 2, i = 3 -> fatto = 2 * 3 = 6 -> i = 4
fatto = 6, i = 4 -> fatto = 6 * 4 = 24 -> i = 5
fatto = 24, i = 5 -> fatto = 24 * 5 = 120 -> i = 6
Ora 6> 5, quindi la condizione di test diventa falsa e il ciclo viene terminato. Viene visualizzato il valore del fattoriale.
Factorial Using Functions
Questo approccio è noto come approccio modulare e dovrebbe essere seguito per la programmazione poiché è abbastanza efficiente. Uno dei suoi vantaggi è che quando dobbiamo apportare modifiche al codice, invece di modificare il codice completo, possiamo semplicemente modificare la funzione interessata. Il codice per trovare il fattoriale di un numero utilizzando questo approccio è mostrato di seguito
java parse string fino ad oggi
#include long factorial (int num) // funzione per il calcolo fattoriale che accetta un valore intero come parametro e restituisce un valore di tipo 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 }
Produzione - Fattoriale di 5 = 120
Spiegazione-
La logica per il programma è la stessa tranne per il fatto che viene utilizzata una funzione diversa per calcolare il fattoriale e restituire il valore al metodo principale da cui inizia l'esecuzione.
Fattoriale utilizzando la ricorsione
La ricorsione è il processo in cui una funzione chiama se stessa e la funzione corrispondente è chiamata funzione ricorsiva. Consiste di due parti: una condizione di base e una chiamata ricorsiva. La soluzione alla condizione di base viene fornita mentre la soluzione al valore più grande può essere risolta convertendola in valori più piccoli fino a raggiungere e utilizzare la soluzione di base.
Di seguito è riportato il codice per la ricerca fattoriale utilizzando la ricorsione: -
#include int fact (int) // function prototype int main () {int num printf ('Immettere il numero il cui fattoriale deve essere trovato:') 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 } } Produzione - Fattoriale di 5 = 120
Spiegazione -Supponiamo che l'utente inserisca 5 come input, quindi nel metodo main () il valore di num è 5. Mentre il flusso va nell'istruzione printf (riga 12) viene effettuata una chiamata alla funzione fact (5). Ora, per fact (5) num è 5 che non è uguale a 0, quindi il flusso va all'istruzione else dove nell'istruzione return viene effettuata una chiamata ricorsiva e fact (4). Il processo viene ripetuto fino al raggiungimento della condizione di base, ovvero num = 0 e viene restituito 1. Ora il flusso va a fact (1) da dove viene restituito 1 (come per fact (1) num = 1) * 1 (valore restituito da fact (0)). Questo processo viene ripetuto fino a ottenere il valore richiesto.
Complessità temporale e spaziale: iterazione V / S della ricorsione
Per la ricorsione
Per quanto riguarda complessità temporale , sappiamo che il fattoriale 0 è l'unico confronto. Quindi T (0) = 1. Per fattoriale di qualsiasi altro numero il processo implica un confronto, una moltiplicazione, una sottrazione e una chiamata di funzione. Perciò
T (n) = T (n-1) +3
= T (n-2) +6
= T (n-3) +9
= & hellip.
= T (n-k) + 3k
Poiché sappiamo che T (0) = 1 e per k = n, (n-k) = 0
Quindi T (n) = T (0) + 3n
= 1 + 3n
come lanciare un double a un int
Pertanto la complessità temporale del codice è O (n).
Per quanto riguarda complessità spaziale, per ogni chiamata viene creato uno stack che verrà mantenuto fino a quando il suo valore non saràcalcolato e restituito. Ad esempio per n = 5 dovranno essere mantenuti i seguenti stack
f (5) -> f (4) -> f (3) -> f (2) -> f (1) -> f (0)
Come possiamo vedere, dovranno essere mantenuti 5 stack fino a quando non verrà raggiunta una chiamata ad f (0) il cui valore ènoto e viene restituito. Pertanto per n fattoriale, dovranno essere mantenuti n stack. Quindi complessità spazialeè O (n). È anche evidente dalle immagini sopra che per n = 5, dovranno essere 5 pilemantenuto. Pertanto per n fattoriale, dovranno essere mantenuti n stack. Quindi la complessità dello spazio è O (n).
Per iterazione
Per quanto riguarda complessità temporale, ci sono n iterazioni all'interno del ciclo, quindi la complessità temporale è O (n).
Per quanto riguarda complessità spaziale, per la soluzione iterativa c'è solo uno stack che deve essere mantenuto e viene utilizzata una variabile intera. Quindi la complessità dello spazio è O (1).
Questo è tutto per questo articolo. Spero che tu abbia capito il concetto del programma fattoriale in C insieme alle complessità temporali.
Se incontri delle domande, sentiti libero di porre tutte le tue domande nella sezione commenti del 'programma fattoriale in C' e il nostro team sarà lieto di rispondere.