Compute X^Y For Floats and Negative Values

Solution: Fast Exponentiation with Full Edge Case Handling

function pow(x, y) {
    // Handle edge cases first

    // 0^0 is undefined, but conventionally return 1
    if (x === 0 && y === 0) return 1;

    // 0^positive = 0
    if (x === 0 && y > 0) return 0;

    // 0^negative = infinity (undefined)
    if (x === 0 && y < 0) return Infinity;

    // x^0 = 1 for any x
    if (y === 0) return 1;

    // 1^y = 1 for any y
    if (x === 1) return 1;

    // (-1)^y alternates between 1 and -1 for integers
    if (x === -1) {
        return y % 2 === 0 ? 1 : -1;
    }

    // Handle negative base with fractional exponent (complex result)
    if (x < 0 && !Number.isInteger(y)) {
        return NaN; // Would be complex number
    }

    // For floating point exponents, use logarithms
    if (!Number.isInteger(y)) {
        // x^y = e^(y * ln(x))
        if (x < 0) return NaN; // Already checked above
        return Math.exp(y * Math.log(Math.abs(x)));
    }

    // From here, y is an integer

    // Handle negative exponent: x^(-y) = 1 / x^y
    let isNegativeExp = y < 0;
    y = Math.abs(y);

    // Fast exponentiation (iterative)
    let result = 1;
    let base = x;

    while (y > 0) {
        // If current bit is 1, multiply result by current base
        if (y % 2 === 1) {
            result *= base;
        }

        // Square the base for next bit
        base *= base;

        // Shift to next bit
        y = Math.floor(y / 2);
    }

    // Apply negative exponent if needed
    if (isNegativeExp) {
        result = 1 / result;
    }

    return result;
}

// Test cases
console.log(pow(2, 10));        // 1024
console.log(pow(2, -3));        // 0.125 (1/8)
console.log(pow(-2, 3));        // -8
console.log(pow(-2, 4));        // 16
console.log(pow(2, 0.5));       // 1.414... (sqrt(2))
console.log(pow(0, 0));         // 1 (by convention)
console.log(pow(0, 5));         // 0
console.log(pow(0, -1));        // Infinity
console.log(pow(-2, 0.5));      // NaN (complex number)
console.log(pow(1.5, 3));       // 3.375

Python Version with Better Overflow Handling

import math

def pow(x, y):
    # Edge cases
    if x == 0 and y == 0:
        return 1
    if x == 0:
        return 0 if y > 0 else float('inf')
    if y == 0:
        return 1
    if x == 1:
        return 1
    if x == -1:
        return 1 if int(y) % 2 == 0 else -1

    # Negative base with fractional exponent
    if x < 0 and not float(y).is_integer():
        return float('nan')

    # Floating point exponent
    if not float(y).is_integer():
        return math.exp(y * math.log(abs(x)))

    # Integer exponentiation
    is_negative = y < 0
    y = abs(int(y))

    result = 1
    base = x

    while y > 0:
        if y & 1:  # Check if odd (bit is 1)
            result *= base
        base *= base
        y >>= 1  # Right shift (divide by 2)

    return 1 / result if is_negative else result


# Test all edge cases
test_cases = [
    (2, 10, 1024),
    (2, -3, 0.125),
    (-2, 3, -8),
    (-2, 4, 16),
    (2, 0.5, math.sqrt(2)),
    (0, 0, 1),
    (0, 5, 0),
    (3.5, 2, 12.25),
]

for x, y, expected in test_cases:
    result = pow(x, y)
    print(f"pow({x}, {y}) = {result} (expected ~{expected})")

Complexity Analysis

Time Complexity:

• Integer exponents: O(log y) - we process each bit of y once
• Float exponents: O(1) - using built-in exp/log

Space Complexity: O(1) - iterative solution uses constant space

Comparison with naive approach:

Edge Cases to Test

1. 0^0: Mathematically undefined, return 1 by convention
2. 0^positive: Returns 0
3. 0^negative: Returns Infinity (division by zero)
4. negative^integer: Works fine, handle sign correctly
5. negative^fraction: Complex number, return NaN
6. Large exponents: Can overflow - need BigInt for very large results
7. Very small results: Can underflow to 0

Common Mistakes

1. Forgetting negative exponents: Must convert to 1/result
2. Not handling negative bases: Sign alternates for integer powers
3. Using recursion: Can stack overflow for large exponents
4. Float precision: Using log/exp introduces floating point errors
5. Not checking for complex results: (-2)^0.5 should return NaN

Follow-up Questions

1. How would you handle very large exponents? Use BigInt in JavaScript, or return infinity when overflow detected
2. Can you do it without loops? Recursive version possible but risks stack overflow
3. How would you implement for complex numbers? Need to handle magnitude and phase separately using polar coordinates
4. What about modular exponentiation? Apply mod at each step to prevent overflow: result = (result * base) % mod

Real-World Applications

• Cryptography: RSA encryption uses modular exponentiation
• Computer graphics: Transformations use matrix exponentiation
• Scientific computing: Growth/decay calculations
• Financial modeling: Compound interest calculations

Related Problems

• Function that Multiples 2 Integers - Mathematical operations
• 100 Factorial - Large number handling
• Implement a Function to Return a Ratio - Number conversion