Faktooriohjelma C: Kuinka laskea luvun kerroin?

Positiivisen kokonaisluvun kerroin on kokonaisluvun ja kaikkien sen alapuolella olevien kokonaislukujen tulo, ts. Luvun n (edustaa n!) Kerroin annettaisiin

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

Kerroin 0 on määritelty arvoksi 1 eikä sitä ole määritelty negatiivisille kokonaisluvuille. On olemassa useita tapoja löytää se, jotka on lueteltu alla-

• Factorial-ohjelma C.käyttämällä For-silmukkaa
• Factorial-ohjelmaToiminnot
• Factorial-ohjelmakäyttämällä rekursiota

Aloitetaan.

Kertoimen käyttö silmukalle

Se on helpoin ja yksinkertaisin tapa löytää luvun faktori. Käy ensin koodissa -

.<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 }

Tuotos-

Kerroin 5 = 120

Selitys -

Numero, jonka kerroin on löydettävissä, pidetään syötteenä ja tallennetaan muuttujaan ja tarkistetaan, onko se negatiivinen vai ei. Jos syötetty kokonaisluku on negatiivinen, näytölle tulee asianmukainen viesti. Kertoimen arvoksi on ennalta määritetty 1, koska sen pienin arvo on 1. For-silmukka suoritetaan positiivisille kokonaisluvuille (lukuun ottamatta 0, jonka testiolosuhteet ovat väärät ja siten tosiasia pysyy nolla). For-silmukassa kertoimen arvo kerrotaan jokaisella kokonaisluvulla ja tallennetaan peräkkäin, kunnes syötetty numero saavutetaan. Esimerkiksi tulolle = 5 virtaus menee silmukalle ja seuraavat vaiheet tapahtuvat -

miten Java-sovellus otetaan käyttöön aws: ssä

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

Nyt 6> 5, siksi testiehto muuttuu vääräksi ja silmukka lopetetaan. Kertoimen arvo näytetään.

Faktori funktioiden avulla

Tätä lähestymistapaa kutsutaan modulaariseksi lähestymistavaksi, ja sitä tulisi noudattaa ohjelmoinnissa, koska se on varsin tehokas. Yksi sen eduista on, että kun meidän on tehtävä muutoksia koodiin, koko koodin muuttamisen sijaan voimme vain muokata kyseistä toimintoa. Koodi luvun faktorialan löytämiseksi tällä lähestymistavalla on esitetty alla

#include pitkä kerroin (int num) // funktio laskettaessa kerroin, joka ottaa kokonaisluvun parametrina ja palauttaa int-tyypin arvon {int i pitkä tosiasia = 1 (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 } 

Tuotos - Kerroin 5 = 120

Selitys-

c ++ siirry kohtaan

Ohjelman logiikka on sama paitsi, että eri funktiota käytetään laskemaan kerroin ja palauttamaan arvo päämenetelmälle, josta suoritus alkaa.

Kerroin rekursiota käyttämällä

Rekursio on prosessi, jossa funktio kutsuu itseään ja vastaavaa funktiota kutsutaan rekursiiviseksi funktioksi. Se koostuu kahdesta osasta - perusedellytyksestä ja rekursiivisesta puhelusta. Ratkaisu perusolosuhteisiin tarjotaan, kun taas ratkaisu suurempaan arvoon voidaan ratkaista muuttamalla pienemmiksi arvoiksi, kunnes perusratkaisu saavutetaan ja sitä käytetään.

Alla on koodi faktorin löytämiseksi rekursiolla: -

#include int fact (int) // funktion prototyyppi int main () {int num printf ('Syötä numero, jonka tekijän on löydettävä:') 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 } } 

Tuotos - Kerroin 5 = 120

Selitys -Oletetaan, että käyttäjä syöttää syötteenä 5, sitten main () -menetelmässä num: n arvo on 5. Kun virtaus kulkee printf-käskyssä (rivi 12), kutsutaan tosiasiallista toimintoa (5). Nyt tosiasia (5) num on 5, joka ei ole yhtä suuri kuin 0, joten virta kulkee else-käskyyn, jossa vastalausekkeessa soitetaan rekursiivinen puhelu ja tosiasia (4). Prosessi toistetaan, kunnes perusedellytys, eli luku = 0, saavutetaan ja 1 palautetaan. Nyt virta menee tosiasiaan (1), josta 1 (kuten tosiasia (1) num = 1) * 1 (tosiasialta palautettu arvo (0)) palautetaan. Tätä prosessia toistetaan, kunnes vaadittu arvo saavutetaan.

Ajan ja avaruuden monimutkaisuus - Rekursio V / S-iterointi

Rekursioon

Mitä tulee ajan monimutkaisuus , tiedämme, että kerroin 0 on ainoa vertailu. Siksi T (0) = 1. Minkä tahansa muun numeron laskentaprosessissa prosessi sisältää yhden vertailun, yhden kertomisen, yhden vähennyksen ja yhden funktion kutsun. Siksi

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

Koska tiedämme T (0) = 1 ja k = n, (n-k) = 0

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

Siksi koodin aikakompleksisuus on O (n).

java kuinka käyttää tostringia

Mitä tulee avaruuden monimutkaisuus, jokaiselle puhelulle luodaan pino, jota ylläpidetään, kunnes sen arvo onlaskettu ja palautettu. Esimerkiksi kun n = 5, seuraavat pinot on säilytettävä

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

Kuten voimme nähdä, että 5 pinoa on ylläpidettävä, kunnes f (0) -kutsu on saavutettu, jonka arvo ontiedossa ja palautetaan. Siksi n tekijän osalta n pinoa on ylläpidettävä. Siten avaruuden monimutkaisuuson O (n). Yllä olevista kuvista käy myös ilmi, että n = 5: lle on oltava 5 pinojaylläpidetään. Siksi n tekijän osalta n pinoa on ylläpidettävä. Siten avaruuden monimutkaisuus on O (n).

Iteraatio-

Mitä tulee ajan monimutkaisuus, silmukan sisällä on n iteraatiota, joten aikakompleksisuus on O (n).

Mitä tulee avaruuden monimutkaisuus, iteratiivista ratkaisua varten on vain yksi pino, joka on ylläpidettävä ja käytetään kokonaislukumuuttujaa. Joten avaruuden monimutkaisuus on O (1).

Siinä kaikki tässä artikkelissa. Toivon, että olet ymmärtänyt C-kirjaimen faktoriohjelman käsitteen ja ajan monimutkaisuuden.

Jos kohtaat kysymyksiä, kysy rohkeasti 'C-faktoriohjelman' kommenttiosasta, ja tiimimme vastaa mielellään.