Pow(x, n)

Pow(x, n) - Problem

Math Recursion Medium

Implement pow(x, n), which calculates x raised to the power n (i.e., xⁿ).

You need to handle both positive and negative exponents efficiently.

Note: Your solution should be more efficient than the naive approach of multiplying x by itself n times.

Input & Output

Example 1 — Positive Exponent

$ Input: x = 2.0, n = 10

› Output: 1024.0

💡 Note: 2^10 = 1024. Using binary exponentiation: 2^10 = (2^5)^2 = 32^2 = 1024

Example 2 — Negative Exponent

$ Input: x = 2.1, n = -2

› Output: 0.22676

💡 Note: 2.1^(-2) = 1/(2.1^2) = 1/4.41 ≈ 0.22676

Example 3 — Zero Exponent

$ Input: x = 2.0, n = 0

› Output: 1.0

💡 Note: Any number raised to power 0 equals 1

Constraints

-100.0 < x < 100.0
-2³¹ ≤ n ≤ 2³¹-1
-10⁴ ≤ xⁿ ≤ 10⁴

Visualization

Tap to expand

Asked in

F Facebook 35 G Google 30 Li LinkedIn 25 a Amazon 20

The key insight is using binary exponentiation to reduce O(n) to O(log n). Instead of multiplying x by itself n times, we use the property x^n = (x^(n/2))^2 to halve the problem size. Best approach is iterative binary exponentiation with Time: O(log n), Space: O(1).

Common Approaches

✓ Binary Exponentiation (Fast Power)

⏱️ Time: O(log n) Space: O(log n)

Binary exponentiation uses the property that x^n = (x^(n/2))^2 when n is even, and x^n = x * x^(n-1) when n is odd. This reduces the problem size by half in each step.

Brute Force Multiplication

⏱️ Time: O(n) Space: O(1)

The naive approach multiplies x by itself exactly n times. For negative exponents, we calculate the positive power first then take the reciprocal.

Iterative Binary Exponentiation

⏱️ Time: O(log n) Space: O(1)

Instead of recursion, we can use an iterative approach by examining the binary representation of the exponent. Each bit tells us whether to include the current power of x in our result.

Binary Exponentiation (Fast Power) — Algorithm Steps

Step 1: Handle base cases (n=0 returns 1)
Step 2: For negative n, calculate positive power then take reciprocal
Step 3: Use recursion: if n is even, return (x^(n/2))^2; if odd, return x * x^(n-1)

Visualization

Tap to expand

Step-by-Step Walkthrough

Divide

Split n in half recursively

Conquer

Square the half-power result

Combine

Multiply by x if n is odd

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

double fastPower(double x, long long n) {
    if (n == 0) return 1.0;
    
    double half = fastPower(x, n / 2);
    if (n % 2 == 0) {
        return half * half;
    } else {
        return half * half * x;
    }
}

double solution(double x, int n) {
    if (n >= 0) {
        return fastPower(x, n);
    } else {
        return 1.0 / fastPower(x, -(long long)n);
    }
}

int main() {
    double x;
    int n;
    scanf("%lf", &x);
    scanf("%d", &n);
    
    double result = solution(x, n);
    printf("%f\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each recursive call halves the exponent, so we make log n recursive calls

⚡ Linearithmic

Space Complexity

O(log n)

Recursion stack depth is log n due to halving the problem size each call

⚡ Linearithmic Space

120.0K Views

High Frequency

~15 min Avg. Time

4.5K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Exponentiation (Fast Power) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler