Ang factorial ng isang positibong integer ay produkto ng isang integer at lahat ng mga integer sa ibaba nito, ibig sabihin, ang factorial ng numero n (kinatawan ng n!) Ay ibibigay ng
n! = 1 * 2 * 3 * 4 *. . . . . * n
Ang factorial ng 0 ay tinukoy na 1 at hindi tinukoy para sa mga negatibong integer. Mayroong maraming mga paraan upang hanapin ito na nakalista sa ibaba-
- Factorial Program sa Cgamit ang Para sa loop
- Gumagamit ng Factorial ProgramMga pagpapaandar
- Factorial Programgamit ang Recursion
Magsimula na tayo.
Paggamit ng Factorial Para sa Loop
Ito ang pinakamadali at pinakasimpleng paraan upang makahanap ng factorial ng isang numero. Bisitahin muna natin ang code -
#include int main () {int I, num, fact = 1 // defining factorial as 1 dahil ang pinakamaliit na halaga ay 1 printf ('Magpasok ng isang numero upang makalkula ang factorial nito') scanf ('% d', & num) kung (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 }Output-
Factorial ng 5 = 120
ano ang maluwag na pagkabit sa java
Paliwanag -
Ang bilang na ang factorial ay matatagpuan ay kinuha bilang input at nakaimbak sa isang variable at nasuri kung ito ay negatibo o hindi. Kung ang integer na ipinasok ay negatibo pagkatapos ay ang naaangkop na mensahe ay ipinapakita. Ang halaga ng factorial ay paunang natukoy na 1 dahil ang pinakamaliit na halaga nito ay 1. Ang para sa loop ay isinasagawa para sa mga positibong integer (maliban sa 0 kung saan ang kundisyon sa pagsubok ay hindi totoo at sa gayon ang katotohanan ay mananatiling zero). Sa for loop, ang halaga ng factorial ay pinarami sa bawat integer at sunod-sunod na nakaimbak hanggang maabot ang input number. Halimbawa, para sa input = 5, pupunta ang daloy para sa loop at magaganap ang mga sumusunod na hakbang-
katotohanan = 1, i = 1 -> katotohanan = 1 * 1 = 1 -> i = 2
katotohanan = 1, i = 2 -> katotohanan = 1 * 2 = 2 -> i = 3
katotohanan = 2, i = 3 -> katotohanan = 2 * 3 = 6 -> i = 4
katotohanan = 6, i = 4 -> katotohanan = 6 * 4 = 24 -> i = 5
katotohanan = 24, i = 5 -> katotohanan = 24 * 5 = 120 -> i = 6
Ngayon 6> 5, samakatuwid ang kondisyon ng pagsubok ay naging mali at ang loop ay natapos. Ang halaga ng factorial ay ipinapakita.
Factorial Gamit na Mga Pag-andar
Ang pamamaraang ito ay kilala bilang isang modular na diskarte at dapat sundin para sa pagprograma dahil medyo mabisa ito. Ang isa sa mga kalamangan nito ay kapag kailangan nating gumawa ng mga pagbabago sa code pagkatapos sa halip na baguhin ang kumpletong code, mababago lamang natin ang pag-aalala na pag-andar. Ang code para sa paghahanap ng factorial ng isang numero gamit ang diskarteng ito ay ipinapakita sa ibaba
# isama ang mahabang factorial (int num) // function para sa pagkalkula ng factorial na kumukuha ng isang integer na halaga bilang isang parameter at nagbabalik ng isang int type na halaga {int i long fact = 1 para sa (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 }
Paglabas - Factorial ng 5 = 120
Paliwanag-
Ang lohika para sa programa ay pareho maliban sa iba't ibang pag-andar ay ginagamit upang makalkula ang factorial at ibalik ang halaga sa pangunahing pamamaraan mula sa kung saan nagsisimula ang pagpapatupad.
Factorial Gamit ang Recursion
Ang Recursion ay ang proseso kung saan ang isang pagpapaandar ay tumatawag sa sarili nito at ang kaukulang pag-andar ay tinatawag na recursive function. Binubuo ito ng dalawang bahagi- isang batayang kondisyon at isang recursive na tawag. Ang solusyon sa batayang kondisyon ay ibinibigay habang ang solusyon sa mas malaking halaga ay maaaring malutas sa pamamagitan ng pag-convert sa mas maliit na mga halaga hanggang sa maabot at magamit ang batayang solusyon.
Nasa ibaba ang code para sa paghahanap ng factorial gamit ang recursion: -
#include int fact (int) // function prototype int main () {int num printf ('Ipasok ang numero na hahanapin ang factorial:') scanf ('% d', & num) kung (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 } } Paglabas - Factorial ng 5 = 120
Paliwanag -Ipagpalagay na ang gumagamit ay pumasok sa 5 bilang input, pagkatapos ay sa pangunahing () pamamaraan ang halaga ng num ay 5. Habang dumadaloy ang daloy sa pahayag ng printf (linya 12) isang pag-andar sa katotohanan (5) ang ginawa. Ngayon para sa katotohanan (5) ang num ay 5 na hindi katumbas ng 0, samakatuwid dumadaloy ang pahayag sa iba pang pahayag kung saan sa pagbabalik ng pahayag ay isang recursive na tawag ang ginawa at ang katunayan (4) ay ginawa. Ang proseso ay paulit-ulit hanggang sa kondisyon ng batayan, ibig sabihin, naabot ang num = 0 at ibalik ang 1. Ngayon ang daloy ay papunta sa katotohanan (1) mula sa kung saan ang 1 (tulad ng para sa katotohanan (1) num = 1) * 1 (naibalik ang halagang mula sa katotohanan (0)). Ang prosesong ito ay paulit-ulit hanggang sa makuha ang kinakailangang halaga.
Pagkumplikado ng Oras at Puwang - Pag-ulit ng V / S na pag-ulit
Para sa Recursion-
Tungkol pagiging kumplikado ng oras , alam namin na ang factorial 0 ay ang tanging paghahambing. Samakatuwid T (0) = 1. Para sa factorial ng anumang iba pang numero ang proseso ay nagsasangkot ng isang paghahambing, isang pagpaparami, isang pagbabawas, at isang pag-andar na tawag. Samakatuwid
T (n) = T (n-1) +3
= T (n-2) +6
= T (n-3) +9
= & hellip.
= T (n-k) + 3k
Dahil alam namin ang T (0) = 1 at para sa k = n, (n-k) = 0
Samakatuwid T (n) = T (0) + 3n
= 1 + 3n
Samakatuwid ang pagiging kumplikado ng oras ng code ay O (n).
Tungkol pagiging kumplikado ng espasyo, isang stack ay nilikha para sa bawat tawag na mapapanatili hanggang sa ang halaga nitonagkalkula at bumalik. Halimbawa para sa n = 5 ang mga sumusunod na stack ay kailangang mapanatili
f (5) -> f (4) -> f (3) -> f (2) -> f (1) -> f (0)
Tulad ng nakikita natin na 5 mga stack ay kailangang mapanatili hanggang sa maabot ang isang tawag sa f (0) na ang halaga aykilala at ibinalik. Samakatuwid para sa n factorial, ang mga n stack ay kailangang mapanatili. Kaya ang pagiging kumplikado ng espasyoay O (n). Malinaw din mula sa mga larawan sa itaas na para sa n = 5, 5 mga stack ang kailangang magingpinananatili Samakatuwid para sa n factorial, ang mga n stack ay kailangang mapanatili. Sa gayon ang pagiging kumplikado ng espasyo ay O (n).
Para sa Iteration-
Tungkol pagiging kumplikado ng oras, mayroong mga pag-ulit sa loob ng loop, samakatuwid ang pagiging kumplikado ng oras ay O (n).
Tungkol pagiging kumplikado ng espasyo, para sa umuulit na solusyon mayroon lamang isang stack na kailangang panatilihin at ginagamit ang isang integer variable. Kaya ang pagiging kumplikado ng espasyo ay O (1).
Iyon lang ang para sa artikulong ito. Inaasahan kong naintindihan mo ang konsepto ng factorial program sa C kasama ang mga kumplikadong oras.
Kung may nahahanap kang anumang mga katanungan, huwag mag-atubiling itanong ang lahat ng iyong mga katanungan sa seksyon ng mga komento ng 'factorial program sa C' at ang aming koponan ay nalulugod na sagutin.
pagkakaiba ng java sa pagitan ng hashmap at hashtable