Pow(x, n)

Problem Statement

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

You need to solve this problem efficiently.

What to notice first

• Key insight 1 for Pow(x, n)
• Key insight 2 for solving this problem
• Key insight 3 specific to the approach

Examples

Input	Output	Explanation
Example 1	Result 1	Explanation for example 1
Example 2	Result 2	Explanation for example 2

Constraints

• Constraint 1 for Pow(x, n)
• Constraint 2
• Constraint 3

Real-World Applications

Where this pattern appears

• Database indexing and query optimization
• Buffer management in system memory
• Time-series data analysis and sliding windows
• Image pixel manipulation and batch processing

Complexity Comparison

Approach	Time	Space	Best When
Fast Exponentiation	O(n)	O(1)	When applicable
Iterative	O(n)	O(1)	When applicable
Recursive	O(n)	O(1)	When applicable

Approach 1: Fast Exponentiation

★ Recommended

This approach provides an efficient solution for pow(x, n).

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

powx_n_fast_exponentiation.py

def powx_n_fast_exponentiation(x: float, n: int) -> float:
    """Calculate x^n using fast exponentiation."""
    if n == 0:
        return 1.0
    if n < 0:
        x = 1 / x
        n = -n

    result = 1.0
    while n > 0:
        if n % 2 == 1:
            result *= x
        x *= x
        n //= 2

    return result

# Test cases
print(powx_n_fast_exponentiation(2.0, 10))  # 1024.0
print(powx_n_fast_exponentiation(2.1, 3))  # 9.261

C++

powx_n_fast_exponentiation.cpp

using namespace std;

double powxnFastExponentiation(double x, int n) {
    if (n == 0) return 1.0;

    long long N = n;
    if (N < 0) {
        x = 1 / x;
        N = -N;
    }

    double result = 1.0;
    while (N > 0) {
        if (N % 2 == 1) {
            result *= x;
        }
        x *= x;
        N /= 2;
    }

    return result;
}

int main() {
    cout << powxnFastExponentiation(2.0, 10) << endl;  // 1024.0
    return 0;
}

Java

powx_n_fast_exponentiation.java

public class PowxnFastExponentiation {
    public static double powxnFastExponentiation(double x, int n) {
        if (n == 0) return 1.0;

        long N = n;
        if (N < 0) {
            x = 1 / x;
            N = -N;
        }

        double result = 1.0;
        while (N > 0) {
            if (N % 2 == 1) {
                result *= x;
            }
            x *= x;
            N /= 2;
        }

        return result;
    }

    public static void main(String[] args) {
        System.out.println(powxnFastExponentiation(2.0, 10));  // 1024.0
    }
}

JavaScript

powx_n_fast_exponentiation.js

function powxnFastExponentiation(x, n) {
    if (n === 0) return 1.0;

    let N = n;
    if (N < 0) {
        x = 1 / x;
        N = -N;
    }

    let result = 1.0;
    while (N > 0) {
        if (N % 2 === 1) {
            result *= x;
        }
        x *= x;
        N = Math.floor(N / 2);
    }

    return result;
}

console.log(powxnFastExponentiation(2.0, 10));  // 1024.0
console.log(powxnFastExponentiation(2.1, 3));  // 9.261

Rust

powx_n_fast_exponentiation.rs

fn powx_n_fast_exponentiation(mut x: f64, mut n: i32) -> f64 {
    if n == 0 {
        return 1.0;
    }

    let mut N = n as i64;
    if N < 0 {
        x = 1.0 / x;
        N = -N;
    }

    let mut result = 1.0;
    while N > 0 {
        if N % 2 == 1 {
            result *= x;
        }
        x *= x;
        N /= 2;
    }

    result
}

fn main() {
    println!("{}", powx_n_fast_exponentiation(2.0, 10));  // 1024.0
    println!("{}", powx_n_fast_exponentiation(2.1, 3));  // 9.261
}

Go

powx_n_fast_exponentiation.go

package main

import "fmt"
import "math"

func powxnFastExponentiation(x float64, n int) float64 {
  if n == 0 {
    return 1.0
  }

  N := int64(n)
  if N < 0 {
    x = 1 / x
    N = -N
  }

  result := 1.0
  for N > 0 {
    if N%2 == 1 {
      result *= x
    }
    x *= x
    N /= 2
  }

  return result
}

func main() {
  fmt.Println(powxnFastExponentiation(2.0, 10))  // 1024
}

Approach 2: Iterative

🎯 Interview Favourite

This approach provides an efficient solution for pow(x, n).

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

powx_n_iterative.py

# Python Solution
# Problem: powx-n
# Approach: iterative

# Implementation placeholder for powx_n_iterative
# This file is auto-generated and should contain the solution code.

def powx_n_iterative():
    pass

if __name__ == "__main__":
    pass

C++

powx_n_iterative.cpp

# C++ Solution
# Problem: powx-n
# Approach: iterative

# Implementation placeholder for powx_n_iterative
# This file is auto-generated and should contain the solution code.

def powx_n_iterative():
    pass

if __name__ == "__main__":
    pass

Java

powx_n_iterative.java

# Java Solution
# Problem: powx-n
# Approach: iterative

# Implementation placeholder for powx_n_iterative
# This file is auto-generated and should contain the solution code.

def powx_n_iterative():
    pass

if __name__ == "__main__":
    pass

JavaScript

powx_n_iterative.js

# JavaScript Solution
# Problem: powx-n
# Approach: iterative

# Implementation placeholder for powx_n_iterative
# This file is auto-generated and should contain the solution code.

def powx_n_iterative():
    pass

if __name__ == "__main__":
    pass

Rust

powx_n_iterative.rs

# Rust Solution
# Problem: powx-n
# Approach: iterative

# Implementation placeholder for powx_n_iterative
# This file is auto-generated and should contain the solution code.

def powx_n_iterative():
    pass

if __name__ == "__main__":
    pass

Go

powx_n_iterative.go

# Golang Solution
# Problem: powx-n
# Approach: iterative

# Implementation placeholder for powx_n_iterative
# This file is auto-generated and should contain the solution code.

def powx_n_iterative():
    pass

if __name__ == "__main__":
    pass

Approach 3: Recursive

✓ Simple

This approach provides an efficient solution for pow(x, n).

⏱ Time O(n) Single pass 💾 Space O(1) Minimal storage

Solution Code

Python

powx_n_recursive.py

# Python Solution
# Problem: powx-n
# Approach: recursive

# Implementation placeholder for powx_n_recursive
# This file is auto-generated and should contain the solution code.

def powx_n_recursive():
    pass

if __name__ == "__main__":
    pass

C++

powx_n_recursive.cpp

# C++ Solution
# Problem: powx-n
# Approach: recursive

# Implementation placeholder for powx_n_recursive
# This file is auto-generated and should contain the solution code.

def powx_n_recursive():
    pass

if __name__ == "__main__":
    pass

Java

powx_n_recursive.java

# Java Solution
# Problem: powx-n
# Approach: recursive

# Implementation placeholder for powx_n_recursive
# This file is auto-generated and should contain the solution code.

def powx_n_recursive():
    pass

if __name__ == "__main__":
    pass

JavaScript

powx_n_recursive.js

# JavaScript Solution
# Problem: powx-n
# Approach: recursive

# Implementation placeholder for powx_n_recursive
# This file is auto-generated and should contain the solution code.

def powx_n_recursive():
    pass

if __name__ == "__main__":
    pass

Rust

powx_n_recursive.rs

# Rust Solution
# Problem: powx-n
# Approach: recursive

# Implementation placeholder for powx_n_recursive
# This file is auto-generated and should contain the solution code.

def powx_n_recursive():
    pass

if __name__ == "__main__":
    pass

Go

powx_n_recursive.go

# Golang Solution
# Problem: powx-n
# Approach: recursive

# Implementation placeholder for powx_n_recursive
# This file is auto-generated and should contain the solution code.

def powx_n_recursive():
    pass

if __name__ == "__main__":
    pass

Related Problems

• Two Sum ↗ Easy #1
• Palindrome Number ↗ Easy #9

Interview Tips

Key trade-offs to discuss

• Time vs. space trade-offs between approaches
• Handling edge cases (empty inputs, single elements, duplicates)
• Optimization opportunities and when they matter
• Follow-up variations and constraint changes

← Previous
Next
→