C# में रिकर्सन से संख्या की घात की गणना

C# में रिकर्सन से घात की गणना

रिकर्सन में एक फंक्शन स्वयं को कॉल करता है जब तक बेस केस नहीं पहुंच जाता। घात की गणना: base^exp = base * base^(exp-1), बेस केस exp == 0 पर 1।

रिकर्सिव एल्गोरिदम

long Power(int n, int p) {
    if (p != 0)
        return n * Power(n, p - 1); // रिकर्सिव केस
    return 1;                        // बेस केस
}

पूर्ण उदाहरण

using System;

public class Demo {
    public static void Main() {
        int n = 5;
        int p = 2;
        long result = Power(n, p);
        Console.WriteLine($"{n}^{p} = {result}"); // 25
    }
    
    static long Power(int n, int p) {
        if (p != 0) {
            return n * Power(n, p - 1);
        }
        return 1;
    }
}

आउटपुट

25

एक्सीक्यूशन ट्रेस (5^2)

Power(5, 2)
  → 5 * Power(5, 1)
      → 5 * Power(5, 0)
          → 1 (बेस केस)
      → 5 * 1 = 5
  → 5 * 5 = 25

ऑप्टिमाइज़ेशन: टेल रिकर्सन (Tail Recursion)

C# कंपाइलर टेल कॉल ऑप्टिमाइज़ेशन की गारंटी नहीं देता, लेकिन एक्यूमुलेटर पैटर्न स्टैक ओवरफ्लो रोक सकता है:

static long PowerTail(int n, int p, long acc = 1) {
    if (p == 0) return acc;
    return PowerTail(n, p - 1, acc * n);
}

इटरेटिव विकल्प (अनुशंसित)

static long PowerIterative(int n, int p) {
    long result = 1;
    for (int i = 0; i < p; i++) result *= n;
    return result;
}

बड़े एक्सपोनेंट्स के लिए: एक्सपोनेंशिएशन बाय स्क्वेरिंग (O(log n))

static long PowerFast(long n, long p) {
    long result = 1;
    while (p > 0) {
        if ((p & 1) == 1) result *= n; // अगर p ऑड है
        n *= n;
        p >>= 1; // p /= 2
    }
    return result;
}

तुलना

* C# में TCO गारंटीड नहीं।