# Modular Exponentiation (Power in Modular Arithmetic)

• Difficulty Level : Medium
• Last Updated : 21 May, 2022

Given three numbers x, y and p, compute (xy) % p.

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.```

We have discussed recursive and iterative solutions for power.

Below is discussed iterative solution.

## C++

 `/* Iterative Function to calculate (x^y) in O(log y) */``int` `power(``int` `x, ``int` `y)``{``    ` `    ``// Initialize answer``    ``int` `res = 1;``    ` `    ``// Check till the number becomes zero``    ``while` `(y)``    ``{``        ` `        ``// If y is odd, multiply x with result``        ``if` `(y % 2 == 1)``            ``res = (res * x);``            ` `        ``// y = y/2``        ``y = y >> 1;``        ` `        ``// Change x to x^2``        ``x = (x * x);``    ``}``    ``return` `res;``}` `// This code is contributed by yaswanth0412`

## C

 `/* Iterative Function to calculate (x^y) in O(log y) */``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;``}`

## Java

 `/* Iterative Function to calculate (x^y) in O(log y) */``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``) != ``0``)``            ``res = res * x;`` ` `        ``// y must be even now``        ``y = y >> ``1``; ``// y = y/2``        ``x = x * x;  ``// Change x to x^2``    ``}``    ``return` `res;``}` `// This code is contributed by Dharanendra L V.`

## Python3

 `# Iterative Function to calculate (x^y) in O(log y)``def` `power(x, y):``    ` `    ``# Initialize result``    ``res ``=` `1`   ` ` `    ``while` `(y > ``0``):``      ` `        ``# If y is odd, multiply x with result``        ``if` `((y & ``1``) !``=` `0``):``            ``res ``=` `res ``*` `x`` ` `        ``# y must be even now``        ``y ``=` `y >> ``1` `# y = y/2``        ``x ``=` `x ``*` `x  ``# Change x to x^2``        ` `    ``return` `res` `# This code is contributed by Khushboogoyal499`

## C#

 `/* Iterative Function to calculate (x^y) in O(log y) */``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) != 0)``            ``res = res * x;`` ` `        ``// y must be even now``        ``y = y >> 1; ``// y = y/2``        ``x = x * x;  ``// Change x to x^2``    ``}``    ``return` `res;``}` `// This code is contributed by Dharanendra L V.`

## Javascript

 ``

Efficient Approach:

The problem with above solutions is, overflow may occur for large value of n or x. Therefore, power is generally evaluated under modulo of a large number.

Below is the fundamental modular property that is used for efficiently computing power under modular arithmetic.

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

For example a = 50,  b = 100, p = 13
50  mod 13  = 11
100 mod 13  = 9

(50 * 100) mod 13 = ( (50 mod 13) * (100 mod 13) ) mod 13
or (5000) mod 13 = ( 11 * 9 ) mod 13
or 8 = 8```

Below is the implementation based on above property.

## C++14

 `// Iterative C++ program to compute modular power``#include ``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;``}` `// This code is contributed by shubhamsingh10`

## Java

 `// 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.`

## Python3

 `# 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))`  `# This code is contributed by Nikita Tiwari.`

## C#

 `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));``  ``}``}` `// This code is contributed by Dharanendra L V.`

## PHP

 ` 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``?>`

## Javascript

 `// 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));` `// This code is contributed by _saurabh_jaiswal`
Output
`Power is 6`

Time Complexity: O(Log y).

Auxiliary Space: O(1), as we are not using any extra space.

Modular exponentiation (Recursive)