Pow(x, n) - Practice Coding Problems

Pow(x, n) - Problem

Math Recursion Medium

Power Function Implementation

You need to implement your own version of the mathematical power function that calculates xⁿ (x raised to the power of n).

Goal: Given a base number x and an exponent n, return the result of xⁿ.

Key Challenges:
• Handle negative exponents (fractional results)
• Handle large exponents efficiently
• Deal with edge cases like x=0, n=0
• Avoid timeout for large values of n

Example: pow(2, 10) should return 1024, and pow(2, -2) should return 0.25.

Input & Output

example_1.py — Basic Power

$ Input: x = 2.0, n = 10

› Output: 1024.0

💡 Note: 2^10 = 2 × 2 × 2 × 2 × 2 × 2 × 2 × 2 × 2 × 2 = 1024

example_2.py — Negative Exponent

$ Input: x = 2.1, n = 3

› Output: 9.261

💡 Note: 2.1^3 = 2.1 × 2.1 × 2.1 = 9.261

example_3.py — Negative Exponent

$ Input: x = 2.0, n = -2

› Output: 0.25

💡 Note: 2^(-2) = 1/(2^2) = 1/4 = 0.25

Visualization

Tap to expand

Understanding the Visualization

Base Case

If n = 0, return 1 (any number^0 = 1)

Divide

Compute half_power = x^(n/2) recursively

Square

Square the half_power to get x^n

Handle Odd

If n is odd, multiply by one extra x

Key Takeaway

🎯 Key Insight: By using the mathematical property x^n = (x^(n/2))^2, we can reduce the problem size by half at each step, achieving logarithmic time complexity instead of linear!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We divide n by 2 at each recursive step, so we make log n recursive calls

⚡ Linearithmic

Space Complexity

O(log n)

Recursion depth is log n due to the call stack

⚡ Linearithmic Space

Constraints

-100.0 < x < 100.0
-2³¹ ≤ n ≤ 2³¹-1
-10⁴ ≤ xⁿ ≤ 10⁴
Important: Your solution must handle negative exponents correctly

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28 🍎 Apple 22

The optimal solution uses fast exponentiation (exponentiation by squaring) to achieve O(log n) time complexity. Instead of multiplying x by itself n times, we recursively compute x^n/2 and square the result, handling odd exponents by multiplying by an extra x.

Common Approaches

Approach	Time	Space	Notes
✓ Fast Exponentiation (Divide and Conquer)	O(log n)	O(log n)	Use exponentiation by squaring to achieve O(log n) time complexity
Brute Force (Repeated Multiplication)	O(n)	O(1)	Multiply x by itself n times using a simple loop

Fast Exponentiation (Divide and Conquer) — Algorithm Steps

Handle base cases: n = 0 returns 1
If n is negative, convert to positive and take reciprocal
If n is even: x^n = (x^(n/2))^2
If n is odd: x^n = x * (x^(n/2))^2
Recursively compute x^(n/2) and square it

Visualization

Tap to expand

Step-by-Step Walkthrough

Divide

Split exponent in half

Conquer

Recursively compute half power

Square

Square the result for efficiency

Code -

solution.c — C

#include <stdio.h>

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

double myPow(double x, int n) {
    long long longN = n;
    if (longN < 0) {
        return 1.0 / fastPow(x, -longN);
    }
    return fastPow(x, longN);
}

int main() {
    double x;
    int n;
    scanf("%lf %d", &x, &n);
    printf("%.5f\n", myPow(x, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

We divide n by 2 at each recursive step, so we make log n recursive calls

⚡ Linearithmic

Space Complexity

O(log n)

Recursion depth is log n due to the call stack

⚡ Linearithmic Space

Constraints

-100.0 < x < 100.0
-2³¹ ≤ n ≤ 2³¹-1
-10⁴ ≤ xⁿ ≤ 10⁴
Important: Your solution must handle negative exponents correctly

89.5K Views

High Frequency

~15 min Avg. Time

2.8K 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Fast Exponentiation (Divide and Conquer) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler