A pozitív egész tényezője egy egész szám és az alatta lévő összes szám szorzata, vagyis az n szám faktoriálisát (amelyet n jelöl!)
n! = 1 * 2 * 3 * 4 *. . . . . * n
A 0 faktoriális értéke 1, és negatív egész számokra nincs meghatározva. Többféle módon lehet megtalálni, amelyeket az alábbiakban sorolunk fel:
- Faktori program C-bena For hurok használatával
- Faktoriális program használataFunkciók
- Faktoriális Programa Rekurzió használatával
Lássunk neki.
Faktoriális használat a hurok számára
Ez a legegyszerűbb és legegyszerűbb módja a szám faktoriális számának megtalálásában. Először keressük fel a kódot -
#include int main () {int I, num, fact = 1 // faktoriális meghatározása 1-nek, mivel a legkisebb érték 1 printf („Adjon meg egy számot a faktoriális számításához”) scanf („% d”, & 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 }Kimenet-
5-ös tényező = 120
hogyan lehet létrehozni singleton osztályt java-ban
Magyarázat -
A számot, amelynek tényezője megtalálható, bemeneti értéknek vesszük, és egy változóban tároljuk, és ellenőrizzük, hogy negatív-e vagy sem. Ha a megadott egész szám negatív, akkor a megfelelő üzenet jelenik meg. A faktoriális érték előre megadva 1, mivel a legkisebb értéke 1. A for ciklust pozitív egész számokra hajtjuk végre (kivéve 0-t, amelynél a tesztfeltétel hamis, és így a tény nulla marad). A for ciklusban a faktoriális értéket megszorozzuk minden egész számmal, és egymás után tároljuk, amíg el nem érjük a bemeneti számot. Például bemenet = 5 esetén az áramlás a hurokhoz megy, és a következő lépések történnek -
tény = 1, i = 1 -> tény = 1 * 1 = 1 -> i = 2
tény = 1, i = 2 -> tény = 1 * 2 = 2 -> i = 3
tény = 2, i = 3 -> tény = 2 * 3 = 6 -> i = 4
tény = 6, i = 4 -> tény = 6 * 4 = 24 -> i = 5
tény = 24, i = 5 -> tény = 24 * 5 = 120 -> i = 6
Most 6> 5, ezért a tesztfeltétel hamis lesz, és a hurok megszűnik. Megjelenik a faktoriális érték.
Faktoriális függvények használata
Ezt a megközelítést moduláris megközelítésnek nevezik, és a programozás során követni kell, mivel meglehetősen hatékony. Az egyik előnye, hogy amikor módosítanunk kell a kódot, akkor a teljes kód megváltoztatása helyett csak módosíthatjuk az érintett függvényt. Az alábbiakban látható a szám faktoriális számának ilyen megközelítéssel történő megkeresésére szolgáló kód
#include hosszú faktoriális (int szám) // függvény a faktoriál kiszámításához, amely egy egész értéket vesz paraméterként és egy int típusú értéket ad vissza {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 }
Kimenet - 5-ös tényező = 120
system.exit (0)
Magyarázat-
A program logikája ugyanaz, azzal a különbséggel, hogy a függvény kiszámításához és az érték visszaadásához a fő módszerhez különböző függvényeket használnak, ahonnan a végrehajtás megkezdődik.
Faktoriális rekurzió használata
A rekurzió az a folyamat, amelyben egy függvény meghívja magát, a megfelelő függvényt pedig rekurzív függvénynek. Két részből áll - egy alapfeltételből és egy rekurzív hívásból. Az alapfeltétel megoldása biztosított, míg a nagyobb érték megoldása kisebb értékekre történő átalakítással oldható meg, amíg az alapoldatot el nem érik és felhasználják.
Az alábbiakban megtalálható a rekurzióval történő faktoriális keresés kódja: -
#include int fact (int) // függvény prototípus int main () {int num printf ('Írja be azt a számot, amelynek faktoriálját meg kell találni:') 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 } } Kimenet - 5-ös tényező = 120
Magyarázat -Tegyük fel, hogy a felhasználó 5-öt ad meg bemenetként, majd a main () metódusban a num értéke 5. Amint a folyamat a printf utasításban megy (12. sor), tényhívás (5) történik. Most az (5) szám értéke 5, amely nem egyenlő 0-val, ezért az áramlás az else utasításba megy, ahol a visszatérési utasításban rekurzív hívást hajtanak végre, és tényt (4) hajtanak végre. A folyamatot addig ismételjük, amíg az alapfeltétel, azaz a num = 0 el nem éri, és az 1 vissza nem tér. Most az áram tényre megy (1), ahonnan 1 (mint a tény (1) szám = 1) * 1 (a tényből (0) visszaadott érték) visszatér. Ezt a folyamatot addig ismételjük, amíg a kívánt értéket el nem érjük.
Idő és tér komplexitás - Rekurziós V / S iteráció
Rekurzióhoz-
Ami azt illeti az idő bonyolultsága , tudjuk, hogy a faktoriális 0 az egyetlen összehasonlítás. Ezért T (0) = 1. Bármely más szám faktoriális vonatkozásában a folyamat egy összehasonlítást, egy szorzást, egy kivonást és egy függvényhívást tartalmaz. Ebből adódóan
különbség a báb és a séf között
T (n) = T (n-1) +3
= T (n-2) +6
= T (n-3) +9
= & hellip.
= T (n-k) + 3k
Mivel tudjuk, hogy T (0) = 1 és k = n esetén (n-k) = 0
Ezért T (n) = T (0) + 3n
= 1 + 3n
Ezért a kód időbeli összetettsége O (n).
Ami azt illeti az űr összetettsége, minden híváshoz egy verem jön létre, amelyet addig tartanak fenn, amíg az értéke nem leszkiszámolta és visszatért. Például n = 5 esetén a következő kötegeket kell fenntartani
f (5) -> f (4) -> f (3) -> f (2) -> f (1) -> f (0)
Mint láthatjuk, 5 köteget kell fenntartani, amíg el nem érjük az f (0) hívást, amelynek értékeismert és visszaküldik. Ezért n tényező esetén n halmot kell fenntartani. Így a tér bonyolultságajelentése O (n). A fenti képekből az is nyilvánvaló, hogy n = 5 esetén 5 kötegnek kell lenniefenntartott. Ezért n tényező esetén n halmot kell fenntartani. Így a tér bonyolultsága O (n).
Iterációra-
Ami azt illeti az idő összetettsége, a cikluson belül n iteráció van, ezért az idő bonyolultsága O (n).
Ami azt illeti az űr összetettsége, az iteratív megoldáshoz csak egy verem van fenn, amelyet fenn kell tartani, és egy egész változót használunk. Tehát a tér bonyolultsága O (1).
Ennyi ehhez a cikkhez. Remélem, megértette a faktori program fogalmát C-ben, az idő bonyolultságával együtt.
Ha bármilyen kérdéssel találkozik, nyugodtan tegye fel minden kérdését a „faktori program C-ben” megjegyzés rovatban, és csapatunk örömmel válaszol.