Faktorprogram i C: Hvordan beregnes et fakturafaktor af et tal?

Faktor for et positivt heltal er produktet af et heltal, og alle heltal under det, dvs. faktoriet for tallet n (repræsenteret af n!) Ville blive givet ved

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

Faktoriet på 0 er defineret til at være 1 og er ikke defineret for negative heltal. Der er flere måder at finde det på, som er angivet nedenfor -

• Faktorprogram i Cved hjælp af For-løkke
• Faktorprogram ved hjælp afFunktioner
• Faktorprogramved hjælp af rekursion

Lad os komme igang.

Faktor, der bruger til løkke

Det er den nemmeste og enkleste måde at finde et tal på. Lad os først besøge koden -

hvordan man tager skærmbillede i selen webdriver ved hjælp af java

#include int main () {int I, num, fact = 1 // definerer faktor som 1, da mindste værdi er 1 printf ('Indtast et tal for at beregne dets faktor') scanf ('% d', & num) hvis (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 }

Produktion-

Faktor af 5 = 120

Forklaring -

Nummeret, hvis faktura skal findes, tages som input og lagres i en variabel og kontrolleres, om det er negativt eller ikke. Hvis det indtastede heltal er negativt, vises den relevante meddelelse. Værdien af ​​faktori er foruddefineret til at være 1, da den mindste værdi er 1. For-sløjfen udføres for positive heltal (undtagen 0, hvor testtilstanden er falsk og således faktisk forbliver nul). I for-sløjfen ganges værdien af ​​faktoriel med hvert heltal og lagres successivt, indtil inputnummeret er nået. For eksempel for input = 5 går strømmen til for loop, og følgende trin finder sted -

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

Nu 6> 5 bliver testbetingelsen derfor falsk, og sløjfen afsluttes. Værdien af ​​faktori vises.

Faktor ved hjælp af funktioner

Denne tilgang er kendt som en modulær tilgang og skal følges for programmering, da den er ret effektiv. En af fordelene er, at når vi har brug for at foretage ændringer i koden, så kan vi bare ændre den pågældende funktion i stedet for at ændre den komplette kode. Koden til at finde et nummer på et nummer ved hjælp af denne tilgang er vist nedenfor

# inkluderer lang faktor (int num) // funktion til beregning af faktor, der tager en heltal som parameter og returnerer en int-type værdi {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 } 

Produktion - Faktor af 5 = 120

Forklaring-

Programmets logik er den samme, bortset fra at der bruges en anden funktion til at beregne faktoren og returnere værdien til hovedmetoden, hvorfra udførelsen begynder.

Faktor ved hjælp af rekursion

Rekursion er den proces, hvor en funktion kalder sig selv, og den tilsvarende funktion kaldes rekursiv funktion. Den består af to dele - en basistilstand og et rekursivt opkald. Løsningen til basistilstanden tilvejebringes, mens løsningen til den større værdi kan løses ved at konvertere til mindre værdier, indtil basisopløsningen er nået og brugt.

Nedenfor er koden til at finde faktor ved hjælp af rekursion: -

#include int fact (int) // funktion prototype int main () {int num printf ('Indtast det nummer, hvis faktor skal findes:') scanf ('% d', & num) hvis (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 } } 

Produktion - Faktor på 5 = 120

Forklaring -Antag at brugeren indtaster 5 som input, så i main () -metoden er værdien num 5. Når flowet går i printf-sætningen (linje 12) foretages der en call to fact (5) -funktion. For faktum (5) er num nu 5, som ikke er lig med 0, derfor går flow til den anden sætning, hvor der til gengæld foretages et rekursivt opkald og fakta (4) foretages. Processen gentages, indtil basistilstanden, dvs. num = 0 er nået, og 1 returneres. Nu går flow til fakta (1) hvorfra 1 (som for fakta (1) num = 1) * 1 (værdi returneret fra fakta (0)) returneres. Denne proces gentages, indtil den krævede værdi er opnået.

Tid og rumkompleksitet - Rekursion V / S-iteration

Til rekursion-

Vedrørende tidskompleksitet , vi ved, at faktor 0 er den eneste sammenligning. Derfor er T (0) = 1. Ved fakturering af ethvert andet nummer involverer processen en sammenligning, en multiplikation, en subtraktion og et funktionsopkald. Derfor

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

Da vi kender T (0) = 1 og for k = n, (n-k) = 0

python klasse __init__

Derfor er T (n) = T (0) + 3n
= 1 + 3n

Derfor er tidens kompleksitet O (n).

Vedrørende rumkompleksitet, der oprettes en stak for hvert opkald, som opretholdes, indtil dens værdi erberegnet og returneret. For eksempel for n = 5 skal følgende stakke opretholdes

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

Som vi kan se, skal 5 stakke opretholdes, indtil et opkald til f (0) nås, hvis værdi erkendt og returneres. Derfor skal n-stakke opretholdes i n faktor. Således rumkompleksiteter O (n). Det fremgår også af ovenstående billeder, at der for n = 5 skal være 5 stakkevedligeholdes. Derfor skal n-stakke opretholdes i n faktor. Rumkompleksitet er således O (n).

Til iteration-

Vedrørende tidskompleksitet, der er n iterationer inde i sløjfen, derfor er tidskompleksiteten O (n).

Vedrørende rumkompleksitet, til iterativ løsning er der kun en stak, der skal vedligeholdes, og der bruges en heltalsvariabel. Rumkompleksiteten er altså O (1).

Det er alt sammen til denne artikel. Jeg håber, du har forstået begrebet faktorprogrammet i C sammen med tidens kompleksitet.

Hvis du støder på spørgsmål, er du velkommen til at stille alle dine spørgsmål i kommentarfeltet i 'faktorprogram i C', og vores team vil med glæde svare.