Computer >> कंप्यूटर ट्यूटोरियल >  >> प्रोग्रामिंग >> Python

Python: बहुपद समीकरण की गणना करना

Python में बहुपद (polynomial) समीकरण की गणना करने के लिए गुणांकों की सूची और चर के मान का उपयोग किया जाता है। मानक रूप: aₙxⁿ + aₙ₋₁xⁿ⁻¹ + ... + a₁x + a₀

हॉर्नर की विधि (Horner's Method) - कुशल दृष्टिकोण

यह विधि कम गुणा ऑपरेशन्स का उपयोग करती है और संख्यात्मक रूप से स्थिर होती है।

def evaluate_polynomial(coeffs, x):
    """
    बहुपद का मान निकालें: coeffs[0]*x^n + coeffs[1]*x^(n-1) + ... + coeffs[n]
    जहां coeffs = [a_n, a_{n-1}, ..., a_0] (उच्चतम घात से स्थिरांक तक)
    """
    result = 0
    for coeff in coeffs:
        result = result * x + coeff
    return result

# उदाहरण: 3x^7 - 6x^6 + 3x^5 - x^4 + 23x^3 - 11x^2 + 0x - 8, x=3 पर
coeffs = [3, -6, 3, -1, 23, -11, 0, -8]
x = 3
print(f"P({x}) = {evaluate_polynomial(coeffs, x)}")  # 3349

मूल लेख की विधि (नेस्टेड लूप)

# मूल लेख का दृष्टिकोण (कम कुशल)
my_list = [3, -6, 3, -1, 23, -11, 0, -8]
x = 3
my_list_length = len(my_list)
my_result = 0

for i in range(my_list_length):
    my_sum = my_list[i]
    for j in range(my_list_length - i - 1):
        my_sum = my_sum * x
    my_result = my_result + my_sum

print("मूल विधि परिणाम:", my_result)  # 3349

आउटपुट

मूल विधि परिणाम: 3349
हॉर्नर विधि परिणाम: 3349

NumPy के साथ (सबसे सरल)

import numpy as np

coeffs = [3, -6, 3, -1, 23, -11, 0, -8]
x = 3

# np.polyval गुणांकों को उच्चतम घात से निम्नतम की अपेक्षा करता है
result = np.polyval(coeffs, x)
print(f"NumPy polyval: {result}")  # 3349.0

# बहुपद ऑब्जेक्ट बनाएं
p = np.polynomial.Polynomial(coeffs[::-1])  # NumPy निम्नतम से उच्चतम क्रम चाहता है
print(f"Polynomial ऑब्जेक्ट: {p(x)}")  # 3349.0

सिम्बॉलिक गणना (SymPy)

import sympy as sp

x = sp.symbols('x')
# बहुपद परिभाषित करें
poly = 3*x**7 - 6*x**6 + 3*x**5 - x**4 + 23*x**3 - 11*x**2 + 0*x - 8

# मान निकालें
val = poly.subs(x, 3)
print(f"SymPy परिणाम: {val}")  # 3349

# विस्तारित रूप देखें
print(f"बहुपद: {poly.expand()}")

व्यावहारिक उदाहरण

def polyval(coeffs, x):
    """बहुपद मान निकालें - हॉर्नर की विधि"""
    return sum(c * (x ** i) for i, c in enumerate(reversed(coeffs)))

# टेस्ट केस
test_cases = [
    ([1, -2, 1], 2),      # x^2 - 2x + 1 = (x-1)^2, x=2 पर 1
    ([1, 0, -1], 3),      # x^2 - 1, x=3 पर 8
    ([2, 3, 1], 2),       # 2x^2 + 3x + 1, x=2 पर 15
    ([1, -3, 3, -1], 2),  # x^3 - 3x^2 + 3x - 1 = (x-1)^3, x=2 पर 1
]

for coeffs, x_val in test_cases:
    print(f"गुणांक {coeffs}, x={x_val}: {polyval(coeffs, x_val)}")

आउटपुट

गुणांक [1, -2, 1], x=2: 1
गुणांक [1, 0, -1], x=3: 8
गुणांक [2, 3, 1], x=2: 15
गुणांक [1, -3, 3, -1], x=2: 1

मूल लेख के कोड की व्याख्या

मूल कोड में नेस्टेड लूप का उपयोग है:

  • बाहरी लूप: प्रत्येक गुणांक के लिए
  • आंतरिक लूप: गुणांक को x से उचित घात तक गुणा करता है
  • समय जटिलता: O(n²) - द्विघात
  • हॉर्नर की विधि: O(n) - रैखिक, अधिक कुशल

सारांश

विधिसमय जटिलताउपयोग में आसानीसटीकता
नेस्टेड लूप (मूल)O(n²)मध्यमअच्छी
हॉर्नर की विधिO(n)आसानउत्कृष्ट (संख्यात्मक स्थिरता)
NumPy polyvalO(n)सबसे आसानउत्कृष्ट
SymPyO(n)मध्यमसटीक (सिम्बॉलिक)
  1. पायथन प्रोग्राम: लिस्ट का संचयी योग ज्ञात करें पायथन प्रोग्राम: लिस्ट का संचयी योग ज्ञात करें

    इस लेख में हम दी गई समस्या के समाधान के बारे में जानेंगे। समस्या कथन हमें एक लिस्ट दी गई है, हमें संचयी योग के साथ एक लिस्ट बनानी है। उदाहरण # संचयी योग def Cumulative(l): new = [] cumsum = 0 for element in l: cumsum += element new.append(cumsum) return new # ड्राइवर

  1. - 3D सूची बनाने के लिए पायथन प्रोग्राम

    समस्या विवरण 3D सूची का अर्थ 3D सरणी होता है। इस प्रोग्राम में हम पूर्णांक तत्वों के साथ 3D सरणी बनाते हैं। उदाहरण इनपुट: 3×3×2 [[1,1,1],[2,2,2],[3,3,3]], [[4,4,4],[5,5,5],[6,6,6]] एल्गोरिदम 3D सूची का क्रम दिया गया है। फॉर लूप का उपयोग करके सूची बनाएं और डेटा प्रिंट करें। उदाहरण कोड # 3D सूची

  1. - दो डिक्शनरी को मर्ज करने का पायथन प्रोग्राम

    समस्या विवरण इस प्रोग्राम में दो डिक्शनरी दी गई हैं। हमारा कार्य इन दोनों को मर्ज करना है। यहां हम update() विधि का उपयोग करते हैं। अपडेट विधि का उपयोग दो सूचियों को मर्ज करने के लिए किया जा सकता है। यहां दूसरी सूची पहली सूची में मर्ज हो जाती है। यह None लौटाता है जिसका अर्थ है कि कोई नई सूची नहीं ब