सी में फैक्टरियल प्रोग्राम: किसी संख्या के फैक्टरियल की गणना कैसे करें?

एक सकारात्मक पूर्णांक का गुणन एक पूर्णांक और उसके नीचे के सभी पूर्णांकों का गुणनफल होता है। सी। में फैक्टरियल प्रोग्राम लिखना सीखें उदाहरण: 3! = 3 * 2 * 1

धनात्मक पूर्णांक का गुणक एक पूर्णांक का गुणन होता है और इसके नीचे के सभी पूर्णांक, अर्थात, संख्या n का भाज्य (n द्वारा दर्शाया गया!) द्वारा दिया जाएगा।

n! = 1 * 2 * 3 * 4 *। । । । । * एन





0 के भाज्य को 1 के रूप में परिभाषित किया गया है और नकारात्मक पूर्णांक के लिए परिभाषित नहीं किया गया है। इसे खोजने के कई तरीके हैं जो नीचे सूचीबद्ध हैं-

आएँ शुरू करें।



लूप के लिए फैक्टरियल का उपयोग करना

किसी संख्या के फैक्टरियल को खोजना सबसे आसान और सरल तरीका है। हमें पहले कोड पर जाएँ -

# अंतर को मुख्य बनाएं () {int I, num, fact = 1 // फैक्टरिंग को 1 से परिभाषित करें क्योंकि कम से कम मूल्य 1 प्रिंटफ है ('अपने भाज्य की गणना करने के लिए एक संख्या दर्ज करें') scanf ('% d', और संख्या) यदि (संख्या)<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 }

आउटपुट-

java में jit क्या है

5 = 120 का गुणनखंड



स्पष्टीकरण -

वह संख्या जिसका तथ्यात्मक पाया जाना है, इनपुट के रूप में लिया जाता है और एक चर में संग्रहीत किया जाता है और यह जांचा जाता है कि यह नकारात्मक है या नहीं। यदि दर्ज किया गया पूर्णांक ऋणात्मक है, तो उपयुक्त संदेश प्रदर्शित होता है। भाज्य का मान 1 होने के लिए पूर्वनिर्धारित होता है क्योंकि इसका मान 1 होता है। लूप को धनात्मक पूर्णांक के लिए निष्पादित किया जाता है (0 को छोड़कर जिसके लिए परीक्षण की स्थिति झूठी है और इस प्रकार तथ्य शून्य रहता है)। लूप के लिए, इनपुट संख्या तक पहुंचने तक फैक्टरियल का मान प्रत्येक पूर्णांक से गुणा किया जाता है और क्रमिक रूप से संग्रहीत किया जाता है। उदाहरण के लिए, इनपुट = 5 के लिए, प्रवाह लूप के लिए जाता है और निम्नलिखित चरण होते हैं-

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

अब 6> 5, इसलिए परीक्षण की स्थिति झूठी हो जाती है और लूप समाप्त हो जाता है। भाज्य का मूल्य प्रदर्शित किया जाता है।

कार्य का उपयोग कर फैक्टर

इस दृष्टिकोण को एक मॉड्यूलर दृष्टिकोण के रूप में जाना जाता है और इसे प्रोग्रामिंग के लिए पालन किया जाना चाहिए क्योंकि यह काफी कुशल है। इसका एक फायदा यह है कि जब हमें कोड में बदलाव करने की जरूरत होती है तो पूरा कोड बदलने के बजाय, हम केवल संबंधित फ़ंक्शन को संशोधित कर सकते हैं। इस दृष्टिकोण का उपयोग करके किसी संख्या के भाज्य को खोजने का कोड नीचे दिखाया गया है

#include लॉन्ग फैक्टोरियल (int संख्या) // फैक्टरियल की गणना के लिए फ़ंक्शन जो एक पैरामीटर के रूप में पूर्णांक मान लेता है और एक इंट टाइप वैल्यू देता है {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 } 

आउटपुट - 5 = 120 का गुणनखंड

व्याख्या-

कार्यक्रम के लिए तर्क समान है सिवाय इसके कि अलग-अलग फ़ंक्शन का उपयोग फैक्टरियल की गणना करने के लिए किया जाता है और उस मूल्य को मुख्य विधि पर लौटाता है जहां से निष्पादन शुरू होता है।

पुनरावृत्ति का उपयोग करने वाले तथ्य

रिकर्सियन वह प्रक्रिया है जिसमें कोई फ़ंक्शन स्वयं को कॉल करता है और संबंधित फ़ंक्शन को पुनरावर्ती फ़ंक्शन कहा जाता है। इसमें दो भाग होते हैं- एक आधार स्थिति और एक पुनरावर्ती कॉल। आधार स्थिति का समाधान प्रदान किया जाता है जबकि बड़े मूल्य का समाधान छोटे समाधानों में परिवर्तित करके हल किया जा सकता है जब तक कि आधार समाधान तक पहुंच और उपयोग नहीं किया जाता है।

नीचे पुनरावृत्ति का उपयोग करके फैक्टरियल खोजने के लिए कोड है: -

#include int fact (int) // फंक्शन प्रोटोटाइप int main () {int num printf ('वह नंबर दर्ज करें जिसकी फैक्ट्री ढूंढनी है:') 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 } } 

आउटपुट - 5 = 120 का गुणनखंड

स्पष्टीकरण -मान लीजिए कि उपयोगकर्ता इनपुट के रूप में 5 में प्रवेश करता है, तो मुख्य () विधि में संख्या का मान 5 है। जैसा कि प्रवाह प्रिंटफ स्टेटमेंट (लाइन 12) में जाता है, कॉल टू फैक्ट (5) फ़ंक्शन होता है। अब तथ्य के लिए (5) संख्या 5 है जो 0 के बराबर नहीं है, इसलिए प्रवाह उसी बयान में जाता है जहां बदले में एक पुनरावर्ती कॉल किया जाता है और तथ्य (4) बनाया जाता है। आधार स्थिति तक प्रक्रिया को दोहराया जाता है, अर्थात, संख्या = 0 तक पहुंच जाता है और 1 वापस आ जाता है। अब प्रवाह तथ्य (1) में जाता है, जहाँ से 1 (तथ्य के लिए (1) संख्या = 1) * 1 (तथ्य (0) से लौटा मूल्य) वापस आ जाता है। आवश्यक मूल्य प्राप्त होने तक इस प्रक्रिया को दोहराया जाता है।

समय और अंतरिक्ष जटिलता - पुनरावृत्ति वी / एस पुनरावृत्ति

पुनरावर्तन के लिए-

के बारे में समय जटिलता , हम जानते हैं कि तथ्यात्मक 0 केवल तुलना है। इसलिए टी (0) = 1। किसी अन्य संख्या के भाज्य के लिए प्रक्रिया में एक तुलना, एक गुणन, एक घटाव और एक फ़ंक्शन कॉल शामिल है। इसलिए

टी (एन) = टी (एन -1) +3
= टी (एन -2) +6
= टी (एन -3) +9
= और नर्क।
= टी (एन-के) + 3k

चूँकि हम T (0) = 1 और k = n, (n-k) = 0 के लिए जानते हैं

इसलिए टी (एन) = टी (0) + 3 एन
= 1 + 3 एन

इसलिए कोड की समय जटिलता O (n) है।

के बारे में अंतरिक्ष जटिलता, प्रत्येक कॉल के लिए एक स्टैक बनाया जाता है जिसे तब तक बनाए रखा जाएगा जब तक कि उसका मूल्य न होगणना की और वापस लौट आया। उदाहरण के लिए n = 5 के लिए निम्नलिखित स्टैक को बनाए रखना होगा

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

जैसा कि हम देख सकते हैं कि 5 स्टैक को तब तक बनाए रखना होगा जब तक कि f (0) पर कॉल नहीं पहुंच जाता है जिसका मूल्य हैज्ञात है और वापस आ गया है। इसलिए एन तथ्य के लिए, n ढेर को बनाए रखना होगा। इस प्रकार अंतरिक्ष जटिलताहै ओ (एन)। उपरोक्त चित्रों से यह भी स्पष्ट है कि n = 5 के लिए, 5 स्टैक होना होगाबनाए रखा। इसलिए एन तथ्य के लिए, n ढेर को बनाए रखना होगा। इस प्रकार अंतरिक्ष जटिलता O (n) है।

Iteration के लिए-

के बारे में समय जटिलता, लूप के अंदर एन पुनरावृत्तियों हैं, इसलिए समय जटिलता ओ (एन) है।

उथला बनाम गहरी प्रति जावा

के बारे में अंतरिक्ष जटिलता, पुनरावृत्ति समाधान के लिए केवल एक स्टैक होता है जिसे बनाए रखने की आवश्यकता होती है और एक पूर्णांक चर का उपयोग किया जाता है। तो अंतरिक्ष जटिलता हे (1) है।

इस लेख के लिए बस इतना ही मुझे उम्मीद है कि आपने समय जटिलताओं के साथ सी में फैक्टरियल कार्यक्रम की अवधारणा को समझ लिया है।

अगर आपको कोई प्रश्न आता है, तो बेझिझक अपने सभी प्रश्न 'सी में तथ्यात्मक कार्यक्रम' अनुभाग में पूछें और हमारी टीम जवाब देने में प्रसन्न होगी।