Write an iterative O(Log y) function for pow(x, y)

Difficulty Level : Medium
Last Updated : 05 Nov, 2021

Given an integer x and a positive number y, write a function that computes x^y under following conditions.
a) Time complexity of the function should be O(Log y)
b) Extra Space is O(1)

Examples:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: x = 3, y = 5
Output: 243

Input: x = 2, y = 5
Output: 32

We strongly recommend that you click here and practice it, before moving on to the solution.

We have discussed recursive O(Log y) solution for power. The recursive solutions are generally not preferred as they require space on call stack and they involve function call overhead.

Following is implementation to compute x^y.

C++

// Iterative C program to implement pow(x, n)
#include <iostream>
using namespace std;
 
/* Iterative Function to calculate (x^y) in O(logy) */
int power(int x, unsigned int y)
{
    int res = 1; // Initialize result
 
    while (y > 0) {
        // If y is odd, multiply x with result
        if (y & 1)
            res = res * x;
 
        // y must be even now
        y = y >> 1; // y = y/2
        x = x * x; // Change x to x^2
    }
    return res;
}
 
// Driver program to test above functions
int main()
{
    int x = 3;
    unsigned int y = 5;
 
    cout<<"Power is "<<power(x, y);
 
    return 0;
}
 
// this code is contributed by shivanisinghss2110

C

// Iterative C++ program to implement pow(x, n)
#include <stdio.h>
 
/* Iterative Function to calculate (x^y) in O(logy) */
int power(int x, unsigned int y)
{
    int res = 1; // Initialize result
 
    while (y > 0) {
        // If y is odd, multiply x with result
        if (y & 1)
            res = res * x;
 
        // y must be even now
        y = y >> 1; // y = y/2
        x = x * x; // Change x to x^2
    }
    return res;
}
 
// Driver program to test above functions
int main()
{
    int x = 3;
    unsigned int y = 5;
 
    printf("Power is %d", power(x, y));
 
    return 0;
}

Java

// Iterative Java program
// to implement pow(x, n)
import java.io.*;
 
class GFG 
{
     
/* Iterative Function to 
calculate (x^y) in O(logy) */
static int power(int x, int y)
{
    // Initialize result
    int res = 1; 
 
    while (y > 0) 
    {
        // If y is odd, 
        // multiply
        // x with result
        if ((y & 1) == 1)
            res = res * x;
 
        // y must be even now
        y = y >> 1; // y = y/2
        x = x * x; // Change x to x^2
    }
    return res;
}
 
// Driver Code
public static void main (String[] args) 
{
    int x = 3;
    int y = 5;
 
    System.out.println("Power is " + 
                        power(x, y));
}
}
 
// This code is contributed
// by aj_36

Python3

# Iterative Python3 program
# to implement pow(x, n)
 
# Iterative Function to
# calculate (x^y) in O(logy)
def power(x, y):
 
    # Initialize result
    res = 1
     
    while (y > 0):
         
        # If y is odd, multiply
        # x with result
        if ((y & 1) == 1) :
            res = res * x
 
        # y must be even 
        # now y = y/2
        y = y >> 1
         
        # Change x to x^2
        x = x * x
     
    return res
 
 
# Driver Code
x = 3
y = 5
 
print("Power is ",
       power(x, y))
 
# This code is contributed
# by ihritik

C#

// Iterative C# program
// to implement pow(x, n)
using System;
 
class GFG
{
     
/* Iterative Function to 
calculate (x^y) in O(logy) */
static int power(int x, int y)
{
    int res = 1; // Initialize result
 
    while (y > 0) 
    {
        // If y is odd, multiply
        // x with result
        if ((y & 1) == 1)
            res = res * x;
 
        // y must be even now
        y = y >> 1; // y = y/2
        x = x * x; // Change x to x^2
    }
    return res;
}
 
// Driver Code
static public void Main ()
{
int x = 3;
int y = 5;
 
Console.WriteLine("Power is "+ 
                   power(x, y));
}
}
 
// This code is contributed
// by aj_36

PHP

<?php
// Iterative php program 
// to implement pow(x, n)>
 
// Iterative Function to 
// calculate (x^y) in O(logy)
 
function power($x, $y)
{
     
    // Initialize result
    $res = 1;     
 
    while ($y > 0)
    {
         
        // If y is odd, multiply
        // x with result
        if ($y & 1)
            $res = $res * $x;
 
        // y must be even now
         
        // y = y/2
        $y = $y >> 1; 
         
        // Change x to x^2
        $x = $x * $x; 
    }
    return $res;
}
 
    // Driver Code
    $x = 3;
    $y = 5;
 
    echo "Power is ", power($x, $y);
 
// This code is contributed by ajit
?>

Javascript

<script>
 
// Iterative Javascript program to implement pow(x, n) 
 
/* Iterative Function to calculate (x^y) in O(logy) */
function power(x, y) 
{ 
// Initialize result 
    let res = 1; 
 
    while (y > 0) { 
        // If y is odd, multiply x with result 
        if (y & 1) 
            res = res * x; 
 
        // y must be even now 
        y = y >> 1; // y = y/2 
        x = x * x; // Change x to x^2 
    } 
    return res; 
} 
 
// Driver program to test above functions 
  
    let x = 3; 
    y = 5; 
 
    document.write("Power is " + power(x, y)); 
 
     
// This code is contributed by Mayank Tyagi
 
</script>

Output:

Power is 243

Time Complexity: O(log y)

Auxiliary Space: O(1)

This article is contributed by Udit Gupta. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

My Personal Notes