Faktorprogram i C: Hvordan beregner man et faktor av et tall?

Faktor av et positivt heltall er produktet av et helt tall, og alle heltallene under det, dvs. faktoriet til tallet n (representert med n!) Vil bli gitt av

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

Faktoren 0 er definert til å være 1 og er ikke definert for negative heltall. Det er flere måter å finne den på som er oppført nedenfor -

• Faktorprogram i Cbruker For loop
• Faktorprogram ved bruk avFunksjoner
• Faktorprogramved hjelp av Rekursjon

La oss komme i gang.

Faktor som bruker For Loop

Det er den enkleste og enkleste måten å finne et talls faktor. La oss først besøke koden -

#include int main () {int I, num, fact = 1 // definerer faktor som 1, siden minste verdi er 1 printf ('Skriv inn et tall for å 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 }

Produksjon-

Faktor på 5 = 120

Forklaring -

Tallet hvis faktor skal finnes, blir tatt som input og lagret i en variabel og blir sjekket om det er negativt eller ikke. Hvis det angitte heltallet er negativt, vises riktig melding. Verdien av faktor er forhåndsdefinert til å være 1, da den minste verdien er 1. For-sløyfen utføres for positive heltall (bortsett fra 0 som testtilstanden er falsk og dermed faktum forblir null). I for-sløyfen multipliseres verdien av faktoriell med hvert heltall og lagres suksessivt til inngangstallet er nådd. For eksempel, for input = 5, går strømmen til for loop og følgende trinn finner sted -

hvordan dynamisk tildeles en matrise i java

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

Nå 6> 5 blir derfor testtilstanden falsk og sløyfen avsluttes. Verdien av faktori vises.

Faktor ved bruk av funksjoner

Denne tilnærmingen er kjent som en modulær tilnærming og bør følges for programmering da den er ganske effektiv. En av fordelene er at når vi trenger å gjøre endringer i koden, kan vi bare endre den aktuelle funksjonen i stedet for å endre den fullstendige koden. Koden for å finne et faktura av et tall ved hjelp av denne tilnærmingen er vist nedenfor

# inkluderer lang faktor (int num) // funksjon for beregning av faktor som tar en heltallverdi som parameter og returnerer en int-type verdi {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 } 

Produksjon - Faktor på 5 = 120

Forklaring-

Fibonacci-serie c ++

Logikken for programmet er den samme, bortsett fra at en annen funksjon brukes til å beregne faktoriet og returnere verdien til hovedmetoden der utførelsen begynner.

Faktor ved bruk av rekursjon

Rekursjon er prosessen der en funksjon kaller seg og den tilsvarende funksjonen kalles rekursiv funksjon. Den består av to deler - en basistilstand og en rekursiv samtale. Løsningen til basistilstanden er gitt mens løsningen til den større verdien kan løses ved å konvertere til mindre verdier til basisløsningen er nådd og brukt.

Nedenfor er koden for å finne faktor ved hjelp av rekursjon: -

#include int fact (int) // function prototype int main () {int num printf ('Skriv inn nummeret som skal være funnet:') 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 } } 

Produksjon - Faktor på 5 = 120

Forklaring -Anta at brukeren angir 5 som inngang, så i hoved () -metoden er verdien på 5. Når strømmen går i printf-setningen (linje 12), blir en samtale til fakta (5) -funksjon utført. Nå for faktum (5) er num 5 som ikke er lik 0, derfor går flyt til den andre setningen der det til gjengjeld blir gjort et rekursivt anrop og fakta (4) blir gjort. Prosessen gjentas til basistilstanden, dvs. num = 0 er nådd og 1 returneres. Nå går flyt til fakta (1) hvor 1 (som for faktum (1) num = 1) * 1 (verdi returnert fra fakta (0)) returneres. Denne prosessen gjentas til ønsket verdi er oppnådd.

Tid og romkompleksitet - Rekursjon V / S-iterasjon

For rekursjon-

Angående tidskompleksitet , vi vet at faktor 0 er den eneste sammenligningen. Derfor er T (0) = 1. For faktori av ethvert annet tall innebærer prosessen en sammenligning, en multiplikasjon, en subtraksjon og en funksjonsanrop. Derfor

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

Siden vi vet T (0) = 1 og for k = n, (n-k) = 0

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

Derfor er tidskompleksiteten til koden O (n).

hva er kokk og dukke

Angående romkompleksitet, det opprettes en stabel for hver samtale som vil opprettholdes til verdien erberegnet og returnert. For eksempel for n = 5 må følgende stabler opprettholdes

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

Som vi kan se at 5 stabler må opprettholdes til en samtale til f (0) er nådd hvis verdi erkjent og blir returnert. Derfor må n stabler opprettholdes i en faktor. Dermed romkompleksiteter på). Det fremgår også av de ovennevnte bildene at for n = 5 må 5 stabler væreopprettholdt. Derfor må n stabler opprettholdes i en faktor. Dermed er romkompleksitet O (n).

For iterasjon-

Angående tidskompleksitet, det er n iterasjoner inne i løkken, derfor er tidskompleksiteten O (n).

Angående romkompleksitet, for iterativ løsning er det bare en stabel som må vedlikeholdes, og en heltallvariabel brukes. Så romkompleksiteten er O (1).

Det er alt for denne artikkelen. Jeg håper du har forstått konseptet med faktorprogrammet i C sammen med tidskompleksitetene.

Hvis du kommer over noen spørsmål, er du velkommen til å stille alle spørsmålene dine i kommentarfeltet til “faktorprogram i C”, og teamet vårt svarer gjerne.