Open In App

Fast Exponentiation using Bit Manipulation

Last Updated : 13 Apr, 2024
Improve
Improve
Like Article
Like
Save
Share
Report

Given two integers A and N, the task is to calculate A raised to power N (i.e. AN).

Examples: 

Input: A = 3, N = 5 
Output: 243 
Explanation: 
3 raised to power 5 = (3*3*3*3*3) = 243

Input: A = 21, N = 4
Output: 194481 
Explanation: 
21 raised to power 4 = (21*21*21*21) = 194481 
 

Naive Approach: 
The simplest approach to solve this problem is to repetitively multiply A, N times and print the product. 

C++
#include <iostream>
using namespace std;

// Function to calculate power using brute force approach
long long findPower(int a, int n) {
    long long result = 1;

    // Multiply 'a' by itself 'n' times
    for (int i = 0; i < n; ++i) {
        result *= a;
    }

    return result;
}

int main() {
    int a = 3;
    int n = 5;

    // Calculate and display the result
    long long result = findPower(a, n);
    cout<<result<<endl;
    return 0;
}
Java
public class Main {
    // Function to calculate power using brute force approach
    static long findPower(int a, int n) {
        long result = 1;

        // Multiply 'a' by itself 'n' times
        for (int i = 0; i < n; ++i) {
            result *= a;
        }

        return result;
    }

    public static void main(String[] args) {
        int a = 3;
        int n = 5;

        // Calculate and display the result
        long result = findPower(a, n);
        System.out.println(result);
    }
}
//This code is contributed by Aman
Python3
# Function to calculate power using brute force approach
def findPower(a, n):
    result = 1

    # Multiply 'a' by itself 'n' times
    for i in range(n):
        result *= a

    return result

# Main function
a = 3
n = 5

# Calculate and display the result
result = findPower(a, n)
print(result)

# This code is contributed by Yash Agarwal(yashagarwal2852002)
C#
using System;

public class PowerCalculation
{
    // Function to calculate power using brute force approach
    public static long FindPower(int a, int n)
    {
        long result = 1;

        // Multiply 'a' by itself 'n' times
        for (int i = 0; i < n; ++i)
        {
            result *= a;
        }

        return result;
    }

    public static void Main(string[] args)
    {
        int a = 3;
        int n = 5;

        // Calculate and display the result
        long result = FindPower(a, n);
        Console.WriteLine(result);
    }
}
Javascript
// Function to calculate power using brute force approach
function findPower(a, n) {
    let result = 1;

    // Multiply 'a' by itself 'n' times
    for (let i = 0; i < n; i++) {
        result *= a;
    }

    return result;
}

// Main function
const a = 3;
const n = 5;

// Calculate and display the result
const result = findPower(a, n);
console.log(result);
//This code is contributed by Aman.

Output
243

Time Complexity: O(N) 
Auxiliary Space: O(1)

Efficient Approach: 
To optimize the above approach, the idea is to use Bit Manipulation. Convert the integer N to its binary form and follow the steps below:  

  • Initialize ans to store the final answer of AN.
  • Traverse until N > 0 and in each iteration, perform Right Shift operation on it.
  • Also, in each iteration, multiply A with itself and update it.
  • If current LSB is set, then multiply current value of A to ans.
  • Finally, after completing the above steps, print ans.

Below is the implementation of the above approach:

C++
// C++ Program to implement
// the above approach
#include <iostream>
using namespace std;

// Function to return a^n
int powerOptimised(int a, int n)
{

    // Stores final answer
    int ans = 1;

    while (n > 0) {

        int last_bit = (n & 1);

        // Check if current LSB
        // is set
        if (last_bit) {
            ans = ans * a;
        }

        a = a * a;

        // Right shift
        n = n >> 1;
    }

    return ans;
}

// Driver Code
int main()
{
    int a = 3, n = 5;

    cout << powerOptimised(a, n);

    return 0;
}
Java
// Java program to implement 
// the above approach 
class GFG{ 

// Function to return a^n 
static int powerOptimised(int a, int n) 
{ 

    // Stores final answer 
    int ans = 1; 

    while (n > 0) 
    { 
        int last_bit = (n & 1); 

        // Check if current LSB 
        // is set 
        if (last_bit > 0)
        { 
            ans = ans * a; 
        } 
        
        a = a * a; 

        // Right shift 
        n = n >> 1; 
    } 
    return ans; 
} 

// Driver Code 
public static void main(String[] args) 
{ 
    int a = 3, n = 5; 

    System.out.print(powerOptimised(a, n)); 
}
}

// This code is contributed by PrinciRaj1992
Python3
# Python3 program to implement
# the above approach

# Function to return a^n
def powerOptimised(a, n):
    
    # Stores final answer 
    ans = 1
    
    while (n > 0):
        last_bit = (n & 1)
        
        # Check if current LSB 
        # is set 
        if (last_bit):
            ans = ans * a
        a = a * a
        
        # Right shift 
        n = n >> 1
        
    return ans

# Driver code
if __name__ == '__main__':
    
    a = 3
    n = 5
    
    print(powerOptimised(a,n))

# This code is contributed by virusbuddah_
C#
// C# program to implement 
// the above approach 
using System;

class GFG{ 

// Function to return a^n 
static int powerOptimised(int a, int n) 
{ 
    
    // Stores readonly answer 
    int ans = 1; 

    while (n > 0) 
    { 
        int last_bit = (n & 1); 

        // Check if current LSB 
        // is set 
        if (last_bit > 0) 
        { 
            ans = ans * a; 
        } 
        a = a * a; 

        // Right shift 
        n = n >> 1; 
    } 
    return ans; 
} 

// Driver Code 
public static void Main(String[] args) 
{ 
    int a = 3, n = 5; 

    Console.Write(powerOptimised(a, n)); 
} 
} 

// This code is contributed by Princi Singh
Javascript
<script>

// Javascript program to implement
// the above approach

// Function to return a^n 
function powerOptimised(a, n) 
{ 
  
    // Stores final answer 
    let ans = 1; 
  
    while (n > 0) 
    { 
        let last_bit = (n & 1); 
  
        // Check if current LSB 
        // is set 
        if (last_bit > 0)
        { 
            ans = ans * a; 
        } 
          
        a = a * a; 
  
        // Right shift 
        n = n >> 1; 
    } 
    return ans; 
}  

    // Driver Code
        
    let a = 3, n = 5; 
  
    document.write(powerOptimised(a, n)); 
      
</script>

Output
243

Time Complexity: O(logN) 
Auxiliary Space: O(1)

Another efficient approach : Recursive exponentiation

Recursive exponentiation is a method used to efficiently compute AN, where A & N are integers. It leverages recursion to break down the problem into smaller subproblems. Follow the steps below :

  • If N = 0, the result is always 1 because any non zero number raised to the power of 0 is 1.
  • If N is even, we can compute AN as (AN/2)2 . This is done by recursively computing AN/2 & squaring the result.
  • If N is odd, we compute AN as A * AN – 1 . Again, we recursively compute AN -1 & multiply the result by A.

Below is the implementation of the above approach :

C++
#include <iostream>
using namespace std;

// Function to calculate A raised to the power N using recursion
long long recursive_exponentiation(long long A, long long N) {
    if (N == 0) {
        // Base case: A^0 = 1
        return 1;
    } else if (N % 2 == 0) {
        // If N is even, recursively compute A^(N/2) and square it
        long long temp = recursive_exponentiation(A, N / 2);
        return temp * temp;
    } else {
        // If N is odd, recursively compute A^(N-1) and multiply by A
        return A * recursive_exponentiation(A, N - 1);
    }
}

int main() {
    // Test case
    cout << recursive_exponentiation(3, 5);
    return 0;
}
Java
public class RecursiveExponentiation {
    // Function to calculate A raised to the power N using recursion
    public static long recursiveExponentiation(long A, long N) {
        if (N == 0) {
            // Base case: A^0 = 1
            return 1;
        } else if (N % 2 == 0) {
            // If N is even, recursively compute A^(N/2) and square it
            long temp = recursiveExponentiation(A, N / 2);
            return temp * temp;
        } else {
            // If N is odd, recursively compute A^(N-1) and multiply by A
            return A * recursiveExponentiation(A, N - 1);
        }
    }

    public static void main(String[] args) {
        // Test case
        System.out.println(recursiveExponentiation(3, 5));
    }
}
Python
def recursive_exponentiation(A, N):
    if N == 0:
        return 1
    elif N % 2 == 0:
        # If N is even, recursively compute A^(N/2) and square it
        temp = recursive_exponentiation(A, N // 2)
        return temp * temp
    else:
        # If N is odd, recursively compute A^(N-1) and multiply by A
        return A * recursive_exponentiation(A, N - 1)

# Test cases
print(recursive_exponentiation(3, 5))  

Output
243

Complexity Analysis :

Time Complexity: O(logN) 

Auxiliary Space: O(1)



Like Article
Suggest improvement
Previous
Next
Share your thoughts in the comments

Similar Reads