Powx N

                                            
class Solution {
public:
    double myPow(double x, int n) {
        if (n == 0) {
            return 1.0;
        }
        
        double temp = myPow(x, n/2);
        
        if (n % 2 == 0) {
            return temp * temp;
        } else {
            if (n > 0) {
                return x * temp * temp;
            } else {
                return (temp * temp) / x;
            }
        }
    }
};

                                            
class Solution(object):
    def myPow(self, x, n):
        """
        :type x: float
        :type n: int
        :rtype: float
        """
        if n == 0:
            return 1
        if n < 0:
            x = 1 / x
            n = -n
        result = 1
        while n > 0:
            if n % 2 == 1:
                result *= x
            x *= x
            n //= 2
        return result

                                            
double myPow(double x, int n) {
    if(n == 0) {
        return 1;
    }
    
    double result = 1.0;
    
    long N = n;
    if(N < 0) {
        x = 1 / x;
        N = -N;
    }
    
    while(N > 0) {
        if(N % 2 == 1) {
            result *= x;
        }
        x *= x;
        N /= 2;
    }
    
    return result;
}

                                            
public class Solution {
    public double MyPow(double x, int n) {
        if (n == 0) {
            return 1;
        }
        if (n < 0) {
            if (n == int.MinValue) {
                return 1 / (x * MyPow(x, int.MaxValue));
            }
            x = 1 / x;
            n = -n;
        }
        double result = 1;
        while (n > 0) {
            if (n % 2 == 1) {
                result *= x;
            }
            x *= x;
            n /= 2;
        }
        return result;
    }
}

                                            
/**
 * @param {number} x
 * @param {number} n
 * @return {number}
 */
var myPow = function(x, n) {
    return Math.pow(x, n);
};

                                            
function myPow(x: number, n: number): number {
    if (n === 0) return 1;
    if (n < 0) {
        x = 1 / x;
        n = -n;
    }
    let result = 1;
    while (n > 0) {
        if (n % 2 === 1) {
            result *= x;
        }
        x *= x;
        n = Math.floor(n / 2);
    }
    return result;
}

                                            
class Solution {
    func myPow(_ x: Double, _ n: Int) -> Double {
        if n == 0 {
            return 1.0
        }
        
        var result = 1.0
        var pow = abs(n)
        
        var base = x
        
        while pow > 0 {
            if pow % 2 == 1 {
                result *= base
            }
            base *= base
            pow /= 2
        }
        
        return n < 0 ? 1 / result : result
    }
}

                                            
class Solution {
    fun myPow(x: Double, n: Int): Double {
        var result = 1.0
        var number = x
        var power = n.toLong()
        
        if (power < 0) {
            number = 1 / number
            power = -power
        }
        
        while (power > 0) {
            if (power % 2 == 1L) {
                result *= number
            }
            number *= number
            power /= 2
        }
        
        return result
    }
}

                                            
class Solution {
  double myPow(double x, int n) {
    if (n == 0) {
      return 1;
    }

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

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

    return result;
  }
}

                                            
func myPow(x float64, n int) float64 {
    if n < 0 {
        return 1 / myPowHelper(x, -n)
    }
    return myPowHelper(x, n)
}

func myPowHelper(x float64, n int) float64 {
    if n == 0 {
        return 1
    }
    
    temp := myPowHelper(x, n/2)
    
    if n%2 == 0 {
        return temp * temp
    }
    
    return x * temp * temp
}

                                            
# @param {Float} x
# @param {Integer} n
# @return {Float}
def my_pow(x, n)
    if n < 0
        return 1.0 / my_pow(x, -n)
    elsif n == 0
        return 1.0
    elsif n % 2 == 0
        return my_pow(x * x, n / 2)
    else
        return x * my_pow(x, n - 1)
    end
end

                                            
object Solution {
    def myPow(x: Double, n: Int): Double = {
        if(n == 0) return 1
        var result = 1.0
        var tempX = x
        var tempN = n.toLong
        if(tempN < 0){
            tempX = 1 / tempX
            tempN = -tempN
        }
        var powN = tempN
        while(powN > 0){
            if(powN % 2 == 1){
                result *= tempX
            }
            tempX *= tempX
            powN /= 2
        }
        result
    }
}

                                            
impl Solution {
    pub fn my_pow(x: f64, n: i32) -> f64 {
        if n == 0 {
            return 1.0;
        }
        let mut result = 1.0;
        let mut power = n as i64;
        
        if power < 0 {
            power = -power;
            let mut x = 1.0 / x;
            let mut base = x;
            while power > 0 {
                if power % 2 == 1 {
                    result *= base;
                }
                base *= base;
                power /= 2;
            }
        } else {
            let mut base = x;
            while power > 0 {
                if power % 2 == 1 {
                    result *= base;
                }
                base *= base;
                power /= 2;
            }
        }
        
        result
    }
}

                                            
defmodule Solution do
  @spec my_pow(x :: float, n :: integer) :: float
  def my_pow(x, n) do
    Float.pow(x, n)
  end
end

To solve this coding challenge, you need to implement a function

pow(x, n)

that calculates \(x\) raised to the power of \(n\) (i.e., \(x^n\)). You'll employ a mathematical technique to efficiently compute the power by using a combination of exponentiation by squaring and handling negative exponents appropriately.

Explanation

The challenge is to compute \( x^n \), where \( x \) is a floating-point number and \( n \) is an integer. Here is a detailed explanation of the steps and considerations to solve this:

Handling Zero Exponent : Any number raised to the power of zero is 1, so if \( n \) is zero, the output should be 1.
Handling Negative Exponent : If \( n \) is negative, we need to invert \( x \) (i.e., use \( \frac{1}{x} \)) and change \( n \) to positive. This transforms the problem into computing \( (\frac{1}{x})^{-n} \).
Exponentiation by Squaring : This method helps in reducing the complexity of power computation from \(O(n)\) to \(O(\log n)\). Here’s how it works:

If \( n \) is odd, multiply the result by \( x \).
Square \( x \) and halve \( n \).
Repeat until \( n \) is zero.

Let’s go through the steps in the pseudocode:

Detailed Steps in Pseudocode

Define the function
pow(x, n)

.

If \( n \) is zero, return 1 immediately as any number raised to the power of zero is 1.

Check if \( n \) is negative.

If it is, invert \( x \) to \( \frac{1}{x} \) and convert \( n \) to positive.

Initialize a result variable to 1.
Use a loop to compute the power:

While \( n \) is greater than zero:

If \( n \) is odd, multiply the result by \( x \).
Square \( x \) and halve \( n \) using integer division.

Return the result.

Here is the pseudocode with comments for these steps:

                                            
FUNCTION pow(x, n)
# Base case: x to the power of 0 is always 1
IF n == 0 THEN
RETURN 1

# If the exponent n is negative, invert x and make n positive
IF n < 0 THEN
x = 1 / x
n = -n

# Initialize result
result = 1

# Loop until n is reduced to zero
WHILE n > 0 DO
# If n is odd, multiply result with current x
IF n % 2 == 1 THEN
result *= x

# Square the base x
x *= x

# Halve the exponent
n //= 2

# Return the final computed power
RETURN result

Step-by-Step Explanation

Function Definition : Define the
pow

function with parameters
x

and
n

.

pow(2.0, 10)
pow(2.1, 3)
pow(2.0, -2)

Base Case Handling :

For
pow(2.0, 0)

, return
1

. This handles cases where the exponent is zero.

Negative Exponent Handling :

If
n

is
-2

, convert \( x \) to \( \frac{1}{x} \) and \( n \) to
2

. This transforms
pow(2.0, -2)

to
pow(0.5, 2)

.

Variable Initialization :

Initialize
result = 1

.

Main Computational Loop :

Loop over while
n > 0

:

If
n

is odd, update the result by multiplying it with the current
x

. This is done because an odd exponent implies one more factor of the base is needed.
Square
x

for the next loop iteration.
Reduce
n

by half using integer division (
n //= 2

).

Return the Result :

Finally,
result

will be the computed power value.

This is essentially how you solve the challenge of computing \( x^n \) efficiently, taking care of both positive and negative exponents, and thus ensuring optimal performance even for large values of \( n \).