Modular Exponentiation (Power in Modular Arithmetic)

Try it on GfG Practice

Modular Exponentiation is the process of computing: x^y (mod  p). where x, y, and p are integers. It efficiently calculates the remainder when x^y is divided by p or (x^y) % p, even for very large y.

Examples : 

Input: x = 2, y = 3, p = 5
Output: 3
Explanation: 2^3 % 5 = 8 % 5 = 3.

Input: x = 2, y = 5, p = 13
Output: 6
Explanation: 2^5 % 13 = 32 % 13 = 6.

[Naive Approach] Repeated Multiplication Method

The simplest way to calculate exponentiation is by multiplying x by itself y times. We use a loop that runs y times, multiplying x with the result in each step while taking the modulus to keep the value manageable. We start with answer = 1 and update it in every step.

#include<bits/stdc++.h>
using namespace std;

int exponentiation(int x, int y, int p){
    int answer = 1;
    for(int i=0;i<y;i++){
        answer = (answer*x)%p;
    }
    return answer%p;
}

int main()
{
    int x = 2;
    int y = 5;
    int p = 13;
    cout<< "Power is "<< exponentiation(x,y,p) << endl;
}

#include <stdio.h>

int exponentiation(int x, int y, int p) {
    int answer = 1;
    for (int i = 0; i < y; i++) {
        answer = (answer * x) % p;
    }
    return answer % p;
}

int main() {
    int x = 2;
    int y = 5;
    int p = 13;
    printf("Power is %d\n", exponentiation(x, y, p));
    return 0;
}

public class Exponentiation {

    static int exponentiation(int x, int y, int p) {
        int answer = 1;
        for (int i = 0; i < y; i++) {
            answer = (answer * x) % p;
        }
        return answer % p;
    }

    public static void main(String[] args) {
        int x = 2;
        int y = 5;
        int p = 13;
        System.out.println("Power is " + exponentiation(x, y, p));
    }
}

def exponentiation(x, y, p):
    answer = 1
    for _ in range(y):
        answer = (answer * x) % p
    return answer % p

# Driver Code
x = 2
y = 5
p = 13
print("Power is", exponentiation(x, y, p))

using System;

class Exponentiation
{
    static int ExponentiationMod(int x, int y, int p)
    {
        int answer = 1;
        for (int i = 0; i < y; i++)
        {
            answer = (answer * x) % p;
        }
        return answer % p;
    }

    public static void Main()
    {
        int x = 2;
        int y = 5;
        int p = 13;
        Console.WriteLine("Power is " + ExponentiationMod(x, y, p));
    }
}

function exponentiation(x, y, p) {
    let answer = 1;
    for (let i = 0; i < y; i++) {
        answer = (answer * x) % p;
    }
    return answer % p;
}

// Driver Code
let x = 2;
let y = 5;
let p = 13;
console.log("Power is", exponentiation(x, y, p));

Power is 6

Time Complexity - O(y)
Auxiliary Space - O(1)

[Expected Approach] Binary Exponentiation Method

Binary exponentiation is a method to compute large powers efficiently using the properties of binary representation. Instead of multiplying the base repeatedly, it breaks the exponent down into powers of 2. Since every number can be represented as a sum of powers of 2, we can use only the set bits (1s) in the binary form of the exponent to determine which multiplications are necessary.

(ab) mod p = ( (a mod p) (b mod p) ) mod p

For example, if we want to compute 3¹⁰, we express 10 in binary as 1010. This means 3¹⁰ can be rewritten as 3⁸×3², skipping unnecessary calculations.
Similarly, for 3¹⁹, where 19 is 10011 in binary, the exponentiation is reduced to 3¹⁶×3²×3¹.

The method works iteratively by checking each bit of the exponent from least significant to most significant. If the bit is 1, we multiply the corresponding power of the base. The exponent is then divided by 2 at each step, which effectively shifts the binary representation, reducing the number of operations to O(log n) instead of O(n), making it highly efficient.

// Iterative C++ program to compute modular power 
#include <iostream>
using namespace std;

/* Iterative Function to calculate (x^y)%p in O(log y) */
int power(long long x, unsigned int y, int p) 
{ 
    int res = 1;     // Initialize result 

    x = x % p; // Update x if it is more than or 
                // equal to p
 
    if (x == 0) return 0; // In case x is divisible by p;

    while (y > 0) 
    { 
        // If y is odd, multiply x with result 
        if (y & 1) 
            res = (res*x) % p; 

        // y must be even now 
        y = y>>1; // y = y/2 
        x = (x*x) % p; 
    } 
    return res; 
} 

// Driver code 
int main() 
{ 
    int x = 2; 
    int y = 5; 
    int p = 13; 
    cout << "Power is " << power(x, y, p); 
    return 0; 
} 

// Iterative Java program to compute modular power 
import java.io.*;
class GFG 
{

  /* Iterative Function to calculate (x^y) in O(log y) */
  static int power(int x, int y, int p)
  {
    int res = 1; // Initialize result

    x = x % p; // Update x if it is more than or
    // equal to p

    if (x == 0)
      return 0; // In case x is divisible by p;

    while (y > 0)
    {

      // If y is odd, multiply x with result
      if ((y & 1) != 0)
        res = (res * x) % p;

      // y must be even now
      y = y >> 1; // y = y/2
      x = (x * x) % p;
    }
    return res;
  }

  // Driver Code
  public static void main(String[] args)
  {
    int x = 2;
    int y = 5;
    int p = 13;
    System.out.print("Power is " + power(x, y, p));
  }
}

// This code is contributed by Dharanendra L V.

# Iterative Python3 program
# to compute modular power

# Iterative Function to calculate
# (x^y)%p in O(log y) 
def power(x, y, p) :
    res = 1     # Initialize result

    # Update x if it is more
    # than or equal to p
    x = x % p 
    
    if (x == 0) :
        return 0

    while (y > 0) :
        
        # If y is odd, multiply
        # x with result
        if ((y & 1) == 1) :
            res = (res * x) % p

        # y must be even now
        y = y >> 1      # y = y/2
        x = (x * x) % p
        
    return res
    

# Driver Code

x = 2; y = 5; p = 13
print("Power is ", power(x, y, p))

using System;
public class GFG
{

  /* Iterative Function to calculate (x^y) in O(log y) */
  static int power(int x, int y, int p)
  {
    int res = 1; // Initialize result

    x = x % p; // Update x if it is more than or
    // equal to p

    if (x == 0)
      return 0; // In case x is divisible by p;

    while (y > 0) 
    {

      // If y is odd, multiply x with result
      if ((y & 1) != 0)
        res = (res * x) % p;

      // y must be even now
      y = y >> 1; // y = y/2
      x = (x * x) % p;
    }
    return res;
  }

  // Driver Code
  static public void Main ()
  {
    int x = 2;
    int y = 5;
    int p = 13;
    Console.Write("Power is " + power(x, y, p));
  }
}

// Iterative Javascript program to 
// compute modular power

// Iterative Function to 
// calculate (x^y)%p in O(log y) 
function power(x, y, p)
{
    // Initialize result
    let res = 1; 

    // Update x if it is more 
    // than or equal to p
    x = x % p; 

    if (x == 0)
        return 0;

    while (y > 0)
    {
        // If y is odd, multiply
        // x with result
        if (y & 1)
            res = (res * x) % p;

        // y must be even now
        
        // y = $y/2
        y = y >> 1; 
        x = (x * x) % p; 
    }
    return res;
}

// Driver Code
let x = 2;
let y = 5;
let p = 13;
document.write("Power is " + power(x, y, p));

<?php
// Iterative PHP program to 
// compute modular power

// Iterative Function to 
// calculate (x^y)%p in O(log y) 
function power($x, $y, $p)
{
    // Initialize result
    $res = 1; 

    // Update x if it is more 
    // than or equal to p
    $x = $x % $p; 

    if ($x == 0)
        return 0;

    while ($y > 0)
    {
        // If y is odd, multiply
        // x with result
        if ($y & 1)
            $res = ($res * $x) % $p;

        // y must be even now
        
        // y = $y/2
        $y = $y >> 1; 
        $x = ($x * $x) % $p; 
    }
    return $res;
}

// Driver Code
$x = 2;
$y = 5;
$p = 13;
echo "Power is ", power($x, $y, $p);

// This code is contributed by aj_36
?>

Power is 6

Time Complexity - O(Log y)
Auxiliary Space - O(1)

To read about recursive method visit, Modular exponentiation (Recursive)