C#-এ রিকার্শন ব্যবহার করে পাওয়ার (ঘাত) ক্যালকুলেট করা

রিকার্শন ব্যবহার করে একটি সংখ্যার ঘাত (power) বের করা একটি ক্লাসিক প্রোগ্রামিং এক্সারসাইজ। বেস কেস: যেকোনো সংখ্যার ০ ঘাত = ১। রিকার্সিভ কেস: x^n = x * x^(n-1)।

বেসিক রিকার্সিভ ইমপ্লিমেন্টেশন

using System;

public class Demo
{
    public static void Main(string[] args)
    {
        int n = 15; // বেস
        int p = 2;  // এক্সপোনেন্ট
        
        long result = Power(n, p);
        Console.WriteLine($"{n}^{p} = {result}");
    }
    
    static long Power(int n, int p)
    {
        if (p == 0) return 1;           // বেস কেস
        if (p < 0) return 0;            // নেগেটিভ এক্সপোনেন্ট (ইন্টিজারের জন্য ০)
        
        return n * Power(n, p - 1);     // রিকার্সিভ কেস
    }
}

আউটপুট

15^2 = 225

অপ্টিমাইজড: Exponentiation by Squaring (O(log n))

নিবিড় রিকার্শন O(n) টাইম নেয়। বাইনরি এক্সপোনেনশিয়েশন (Exponentiation by Squaring) ব্যবহার করে O(log n)-এ করা যায়।

static long PowerOptimized(long n, int p)
{
    if (p == 0) return 1;
    if (p < 0) return 0; // ইন্টিজার ডিভিশনের জন্য
    
    if (p % 2 == 0) // জোড় এক্সপোনেন্ট
    {
        long half = PowerOptimized(n, p / 2);
        return half * half;
    }
    else // বিজোড় এক্সপোনেন্ট
    {
        return n * PowerOptimized(n, p - 1);
    }
}

// আরও সংক্ষিপ্ত ভার্সন
static long PowerFast(long n, int p)
{
    if (p == 0) return 1;
    long half = PowerFast(n, p / 2);
    if (p % 2 == 0) return half * half;
    return n * half * half;
}

ইটেরেটিভ ভার্সন (স্ট্যাক ওভারফ্লো এড়াতে)

static long PowerIterative(long n, int p)
{
    if (p < 0) return 0;
    
    long result = 1;
    while (p > 0)
    {
        if ((p & 1) == 1) // বিজোড় চেক
            result *= n;
        n *= n;
        p >>= 1; // ২ দিয়ে ভাগ (রাইট শিফট)
    }
    return result;
}

বিল্ট-ইন মেথড: Math.Pow

double result = Math.Pow(15, 2); // 225.0 (ডাবল রিটার্ন করে)
// ইন্টিজার পাওয়ার için:
long result = (long)Math.Pow(15, 2);

পারফরম্যান্স তুলনা (১০^১০ ক্যালকুলেট করতে)

বড় সংখ্যার জন্য: BigInteger

using System.Numerics;

static BigInteger BigPower(BigInteger n, int p)
{
    if (p < 0) throw new ArgumentException("নেগেটিভ এক্সপোনেন্ট");
    BigInteger result = 1;
    while (p > 0)
    {
        if ((p & 1) == 1) result *= n;
        n *= n;
        p >>= 1;
    }
    return result;
}

// ব্যবহার
var huge = BigPower(2, 1000); // ২^১০০০ (৩০১ ডিজিট)
Console.WriteLine(huge);

সারসংক্ষেপ

• শিক্ষামূলক: নিবিড় রিকার্শন বুঝতে ভালো
• প্রোডাকশন: ইটেরেটিভ বাইনরি এক্সপোনেনশিয়েশন বা Math.Pow
• বড় সংখ্যা: System.Numerics.BigInteger ব্যবহার করুন
• নেগেটিভ এক্সপোনেন্ট: ফ্লোটিং পয়েন্টে Math.Pow, ইন্টিজারে সমর্থিত নয় (ফ্র্যাকশন হয়)