33343536373839404142434445464748495051525354

#include<bits/stdc++.h>
using namespace std;

// Class definition for the solution
class Solution {
private:
    // Function to calculate power
    // of 'x' raised to 'n'
    double power(double x, long n) {
        // Base case: anything raised to 0 is 1
        if (n == 0) return 1.0;

        // Base case: anything raised to 1 is itself
        if (n == 1) return x;

        // If 'n' is even
        if (n % 2 == 0) {
            // Recursive call: x * x, n / 2
            return power(x * x, n / 2);
        }
        // If 'n' is odd
        // Recursive call: x * power(x, n-1)
        return x * power(x, n - 1);
    }

public:
    // Function to calculate x raised to n
    double myPow(double x, int n) {
        // Store the value of n in a separate variable
        int num = n;

        // If n is negative
        if (num < 0) {
            // Calculate the power of -n and take reciprocal
            return (1.0 / power(x, -1 * num));
        }
        // If n is non-negative
        return power(x, num);
    }
};

int main() {
    Solution sol;
    double x = 2.0;
    int n = 10;

    // Calculate x raised to n
    double result = sol.myPow(x, n);

    // Print the result
    std::cout << x << "^" << n << " = " << result << std::endl;

    return 0;
}

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051

// Class containing power calculation logic
class Solution {
    
    // Helper method to calculate power using recursion
    private double power(double x, long n) {
        // Base case: anything raised to 0 is 1
        if (n == 0) return 1.0;
        
        // Base case: anything raised to 1 is itself
        if (n == 1) return x;
        
        // If 'n' is even
        if (n % 2 == 0) {
            // Recursive call: square the base and halve the exponent
            return power(x * x, n / 2);
        }
        
        // If 'n' is odd
        // Recursive call: multiply base once and reduce exponent by 1
        return x * power(x, n - 1);
    }
    
    // Public method to handle negative exponents as well
    public double myPow(double x, int n) {
        // If 'n' is negative, take reciprocal of positive exponent result
        if (n < 0) {
            return 1.0 / power(x, -n);
        }
        // If 'n' is non-negative
        return power(x, n);
    }
}

// Separate main class for testing
class Main {
    public static void main(String[] args) {
        // Create an instance of Solution
        Solution sol = new Solution();
        
        // Example input
        double x = 2.0;
        int n = 10;

        // Calculate power
        double result = sol.myPow(x, n);

        // Print result
        System.out.println(x + "^" + n + " = " + result);
    }
}