Write some pseudo code to raise a number to a power.

pretty trivial...

int raise(num, power){
if(power==0) return 1;
if(power==1) return num;
return(raise(num, power-1)*num);
}

double Power(int x, int y)
{
    double ret = 1;
    double power = x;

    while (y > 0)
    {
        if (y & 1)
        {
            ret *= power;
        }
        power *= power;
        y >>= 1;
    }

    return ret;
}

In Ruby:
def power(base, power)
  product = 1
  power.times do
    product *= base
  end
  product
end

puts "2^10 = 1024 = #{power(2,10)}"
puts "2^0 = 1 = #{power(2,0)}"
puts "2^1 = 2 = #{power(2,1)}"

If I were an interviewer, I would ask the Aug 29, 2010 poster why he used bitwise operators, and whether he would deploy that code in a production environment, or if he merely wanted to demonstrate, for purposes of the interview, that he understands bitwise operations.

Because it uses dynamic programming and is lots more efficient than your algorithm.

If the power is not integer, use ln and Taylor series

If I'm the interviewer, none of above answers is acceptable.
What if y < 0? what if y < 0 and x == 0?
I'm seeing an endless recursion that will eventually overflow the stack, and the none-recursive one just simply returns 1.

There is a way to do this in a logN way rather than N.

function power(x, n)
{
       if n == 1
             return x;

     // Even numbers
     else if (n%2 == 0)
           return square( power (x, n/2));

     // Odd numbers
     else
            return power(x, n-1);

}

This is from Programming pearls.. interesting way.

small mistake

function power(x, n)
{
       if n == 1
             return x;

     // Even numbers
     else if (n%2 == 0)
           return square( power (x, n/2));

     // Odd numbers
     else
            return power(x, n-1) * x;

}