किसी ऋणात्मक-नहीं पूर्णांक n का फैक्टोरियल, जिसे n! से दर्शाया जाता है, n से कम या उसके बराबर सभी धनात्मक पूर्णांकों का गुणनफल होता है। उदाहरण के लिए, 5! = 5 × 4 × 3 × 2 × 1 = 120। संयोजन और प्रायिकता में फैक्टोरियल मौलिक हैं। यह लेख पायथन में फैक्टोरियल की गणना करने के तीन तरीकों का पता लगाता है: पुनरावृति, पुनरावर्तन, और अनुकूलित math.factorial() फलन।
विषय-सूची
- पुनरावृति द्वारा फैक्टोरियल की गणना
- पुनरावर्ती रूप से फैक्टोरियल की गणना
math.factorial()फलन का उपयोग करना- विधि तुलना
पुनरावृति द्वारा फैक्टोरियल की गणना
पुनरावृति एक सरल तरीका प्रदान करता है। एक लूप क्रमिक रूप से संख्याओं को गुणा करता है:
def factorial_iterative(n):
"""पुनरावृति द्वारा किसी ऋणात्मक-नहीं पूर्णांक का फैक्टोरियल परिकलित करता है।
Args:
n: ऋणात्मक-नहीं पूर्णांक।
Returns:
n का फैक्टोरियल। यदि n 0 है तो 1 देता है।
यदि n ऋणात्मक है तो ValueError उठाता है।
"""
if n < 0:
raise ValueError("ऋणात्मक संख्याओं के लिए फैक्टोरियल परिभाषित नहीं है।")
elif n == 0:
return 1
else:
result = 1
for i in range(1, n + 1):
result *= i
return result
# उदाहरण
number = 5
result = factorial_iterative(number)
print(f"{number} का फैक्टोरियल {result} है") # आउटपुट: 5 का फैक्टोरियल 120 है
यह विधि कुशल और समझने में आसान है, पुनरावर्तन में निहित संभावित स्टैक ओवरफ्लो समस्याओं से बचती है।
पुनरावर्ती रूप से फैक्टोरियल की गणना
पुनरावर्तन एक संक्षिप्त विकल्प प्रदान करता है। एक पुनरावर्ती फलन तब तक स्वयं को कॉल करता है जब तक कि एक आधार मामला (n = 0, 0! = 1) नहीं पहुँच जाता:
def factorial_recursive(n):
"""पुनरावर्ती रूप से किसी ऋणात्मक-नहीं पूर्णांक का फैक्टोरियल परिकलित करता है।
Args:
n: ऋणात्मक-नहीं पूर्णांक।
Returns:
n का फैक्टोरियल। यदि n 0 है तो 1 देता है।
यदि n ऋणात्मक है तो ValueError उठाता है।
"""
if n < 0:
raise ValueError("ऋणात्मक संख्याओं के लिए फैक्टोरियल परिभाषित नहीं है।")
elif n == 0:
return 1
else:
return n * factorial_recursive(n - 1)
# उदाहरण
number = 5
result = factorial_recursive(number)
print(f"{number} का फैक्टोरियल {result} है") # आउटपुट: 5 का फैक्टोरियल 120 है
सुंदर होने के बावजूद, बड़े n के लिए पुनरावर्तन धीमा हो सकता है और बढ़ते कॉल स्टैक के कारण पायथन की पुनरावर्तन गहराई सीमा तक पहुँच सकता है।
math.factorial() फलन का उपयोग करना
पायथन का math मॉड्यूल एक अत्यधिक अनुकूलित factorial() फलन प्रदान करता है:
import math
def factorial_math(n):
"""math.factorial() का उपयोग करके फैक्टोरियल की गणना करता है।
Args:
n: ऋणात्मक-नहीं पूर्णांक।
Returns:
n का फैक्टोरियल।
यदि n ऋणात्मक है या पूर्णांक नहीं है तो ValueError उठाता है।
"""
if not isinstance(n, int) or n < 0:
raise ValueError("इनपुट एक ऋणात्मक-नहीं पूर्णांक होना चाहिए।")
return math.factorial(n)
# उदाहरण
number = 5
result = factorial_math(number)
print(f"{number} का फैक्टोरियल {result} है") # आउटपुट: 5 का फैक्टोरियल 120 है
यह इसकी दक्षता, मजबूती और बड़ी संख्याओं को संभालने के लिए अनुशंसित दृष्टिकोण है, जो अनुकूलित C कोड का लाभ उठाता है।
विधि तुलना
जबकि पुनरावृति और पुनरावर्ती विधियाँ शैक्षिक मूल्य प्रदान करती हैं, व्यावहारिक अनुप्रयोगों में प्रदर्शन और त्रुटि हैंडलिंग के लिए math.factorial() आम तौर पर बेहतर है। चुनाव संदर्भ पर निर्भर करता है: शैक्षिक उद्देश्यों में पुनरावृति या पुनरावर्ती दृष्टिकोणों का पक्ष हो सकता है, जबकि उत्पादन कोड अनुकूलित अंतर्निहित फ़ंक्शन से बहुत लाभान्वित होता है।