জাভা প্রোগ্রাম: রিকার্শন ব্যবহার করে ঘাতাঙ্ক (Power) ক্যালকুলেট করা

রিকার্শন দিয়ে ঘাতাঙ্ক (Power) কী?

a^b (a-এর b ঘাত) হলো a কে b বার নিজের সাথে গুণ করা। রিকার্শনে: power(a, b) = a × power(a, b-1), বেস কেস: power(a, 0) = 1।

ইনপুট ও আউটপুট উদাহরণ

ইনপুট:

Enter the number and its power: 2 and 5

আউটপুট:

The result of 2^5 is 32

অ্যালগরিদম

1. প্রোগ্রাম শুরু করুন
2. তিনটি ইন্টিজার ভেরিয়েবল ঘোষণা করুন: my_power, my_input, result
3. ব্যবহারকারী থেকে বেস (my_input) এবং এক্সপোনেন্ট (my_power) ইনপুট নিন
4. রিকার্সিভ ফাংশন getPower(base, exp) ডিফাইন করুন:
   • বেস কেস: যদি exp == 0 হয়, 1 রিটার্ন করুন
   • রিকার্সিভ কেস: base * getPower(base, exp - 1) রিটার্ন করুন
5. ফাংশন কল করুন এবং ফলাফল স্টোর করুন
6. ফলাফল প্রদর্শন করুন
7. প্রোগ্রাম শেষ করুন

উদাহরণ ১: ব্যবহারকারী ইনপুট নেওয়া

import java.util.Scanner;

public class Power {
    public static void main(String[] args) {
        int my_power, my_input, result;
        my_input = 2;
        my_power = 5;
        
        System.out.println("Required packages have been imported");
        Scanner my_scanner = new Scanner(System.in);
        System.out.println("A reader object has been defined");
        System.out.print("Enter the number : ");
        my_input = my_scanner.nextInt();
        System.out.print("Enter the power value : ");
        my_power = my_scanner.nextInt();
        
        result = getPower(my_input, my_power);
        System.out.println("The result of " + my_input + "^" + my_power + " is " + result);
    }
    
    public static int getPower(int my_input, int my_power) {
        if (my_power != 0) {
            return (my_input * getPower(my_input, my_power - 1));
        } else {
            return 1;
        }
    }
}

উদাহরণ ২: পূর্বনির্ধারিত মান ব্যবহার

public class Power {
    public static void main(String[] args) {
        int my_power = 5, my_input = 2, result;
        System.out.println("The number and its power is defined as " + my_input + " and " + my_power);
        result = getPower(my_input, my_power);
        System.out.println("The result of " + my_input + "^" + my_power + " is " + result);
    }
    
    public static int getPower(int my_input, int my_power) {
        if (my_power != 0) {
            return (my_input * getPower(my_input, my_power - 1));
        } else {
            return 1;
        }
    }
}

রিকার্শন ট্রেস (2^5)

getPower(2, 5)
= 2 * getPower(2, 4)
= 2 * (2 * getPower(2, 3))
= 2 * (2 * (2 * getPower(2, 2)))
= 2 * (2 * (2 * (2 * getPower(2, 1))))
= 2 * (2 * (2 * (2 * (2 * getPower(2, 0)))))
= 2 * (2 * (2 * (2 * (2 * 1))))
= 2 * (2 * (2 * (2 * 2)))
= 2 * (2 * (2 * 4))
= 2 * (2 * 8)
= 2 * 16
= 32

কোড ব্যাখ্যা

• বেস কেস (exp == 0): যেকোনো সংখ্যার ০ ঘাত = ১ (গাণিতিক নিয়ম)
• রিকার্সিভ কেস: base * power(base, exp-1) - এক্সপোনেন্ট ১ কমানো
• স্ট্যাক ডেপথ: এক্সপোনেন্টের মানতেই (এখানে ৫ লেভেল)

নেগেটিভ এক্সপোনেন্ট হ্যান্ডলিং

public static double getPower(double base, int exp) {
    if (exp == 0) return 1;
    if (exp < 0) return 1 / getPower(base, -exp); // 네가েটিভ এক্সপোনেন্ট
    return base * getPower(base, exp - 1);
}

দ্রুত ঘাতাঙ্ক (Exponentiation by Squaring) - O(log n)

রিকার্শন দিয়ে অপ্টিমাইজড ভার্শন:

public static long fastPower(long base, int exp) {
    if (exp == 0) return 1;
    if (exp < 0) return 1 / fastPower(base, -exp);
    
    long half = fastPower(base, exp / 2);
    if (exp % 2 == 0)
        return half * half;
    else
        return half * half * base;
}

// টেল রিকার্সিভ ভার্শন
public static long fastPowerTail(long base, int exp, long acc) {
    if (exp == 0) return acc;
    if (exp % 2 == 1) acc *= base;
    return fastPowerTail(base * base, exp / 2, acc);
}

তুলনা

Java বিল্ট-ইন মেথড

// double রিটার্ন করে
Math.pow(2, 5);     // 32.0
Math.pow(2, -3);    // 0.125
Math.pow(16, 0.5);  // 4.0 (square root)

// ইন্টিজার পাওয়ার (Java 9+)
Math.multiplyExact(2, 2); // overflow চেক করে

বড় সংখ্যা হ্যান্ডলিং (BigInteger)

import java.math.BigInteger;

public static BigInteger bigPower(BigInteger base, int exp) {
    BigInteger result = BigInteger.ONE;
    BigInteger b = base;
    int e = exp;
    
    while (e > 0) {
        if ((e & 1) == 1) result = result.multiply(b);
        b = b.multiply(b);
        e >>= 1;
    }
    return result;
}

সতর্কতা

• ইন্টিজার ওভারফ্লো: 2^31 এর বেশি হলে ইন্টেজার ওভারফ্লো হবে (long বা BigInteger ব্যবহার করুন)
• স্ট্যাক ওভারফ্লো: বড় এক্সপোনেন্ট (১০০০০+) এর জন্য
• নেগেটিভ বেস + ভগ্নাংশ এক্সপোনেন্ট → কমপ্লেক্স নাম্বার (জাভা সাপোর্ট করে না নেটিভলি)