# Modular exponentiation (Recursive)

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

Given three numbers a, b and c, we need to find (ab) % c
Now why do “% c” after exponentiation, because ab will be really large even for relatively small values of a, b and that is a problem because the data type of the language that we try to code the problem, will most probably not let us store such a large number.
Examples:

```Input : a = 2312 b = 3434 c = 6789
Output : 6343

Input : a = -3 b = 5 c = 89
Output : 24```

Auxiliary Space: O(1)

The idea is based on below properties.
Property 1:
(m * n) % p has a very interesting property:
(m * n) % p =((m % p) * (n % p)) % p
Property 2:
if b is even:
(a ^ b) % c = ((a ^ b/2) * (a ^ b/2))%c ? this suggests divide and conquer
if b is odd:
(a ^ b) % c = (a * (a ^( b-1))%c
Property 3:
If we have to return the mod of a negative number x whose absolute value is less than y:
then (x + y) % y will do the trick
Note:
Also as the product of (a ^ b/2) * (a ^ b/2) and a * (a ^( b-1) may cause overflow, hence we must be careful about those scenarios

## C++

 `// Recursive C++ program to compute modular power ` `#include ` `using` `namespace` `std;`   `int` `exponentMod(``int` `A, ``int` `B, ``int` `C) ` `{ ` `    ``// Base cases ` `    ``if` `(A == 0) ` `        ``return` `0; ` `    ``if` `(B == 0) ` `        ``return` `1; `   `    ``// If B is even ` `    ``long` `y; ` `    ``if` `(B % 2 == 0) { ` `        ``y = exponentMod(A, B / 2, C); ` `        ``y = (y * y) % C; ` `    ``} `   `    ``// If B is odd ` `    ``else` `{ ` `        ``y = A % C; ` `        ``y = (y * exponentMod(A, B - 1, C) % C) % C; ` `    ``} `   `    ``return` `(``int``)((y + C) % C); ` `} `   `// Driver code ` `int` `main() ` `{ ` `    ``int` `A = 2, B = 5, C = 13; ` `    ``cout << ``"Power is "` `<< exponentMod(A, B, C); ` `    ``return` `0; ` `} `   `// This code is contributed by SHUBHAMSINGH10`

## C

 `// Recursive C program to compute modular power ` `#include `   `int` `exponentMod(``int` `A, ``int` `B, ``int` `C)` `{` `    ``// Base cases` `    ``if` `(A == 0)` `        ``return` `0;` `    ``if` `(B == 0)` `        ``return` `1;`   `    ``// If B is even` `    ``long` `y;` `    ``if` `(B % 2 == 0) {` `        ``y = exponentMod(A, B / 2, C);` `        ``y = (y * y) % C;` `    ``}`   `    ``// If B is odd` `    ``else` `{` `        ``y = A % C;` `        ``y = (y * exponentMod(A, B - 1, C) % C) % C;` `    ``}`   `    ``return` `(``int``)((y + C) % C);` `}`   `// Driver program to test above functions ` `int` `main() ` `{ ` `   ``int` `A = 2, B = 5, C = 13;` `   ``printf``(``"Power is %d"``, exponentMod(A, B, C)); ` `   ``return` `0; ` `} `

## Java

 `// Recursive Java program ` `// to compute modular power ` `import` `java.io.*; `   `class` `GFG ` `{ ` `static` `int` `exponentMod(``int` `A, ` `                       ``int` `B, ``int` `C) ` `{ ` `        `  `    ``// Base cases ` `    ``if` `(A == ``0``) ` `        ``return` `0``; ` `    ``if` `(B == ``0``) ` `        ``return` `1``; ` `    `  `    ``// If B is even ` `    ``long` `y; ` `    ``if` `(B % ``2` `== ``0``)` `    ``{ ` `        ``y = exponentMod(A, B / ``2``, C); ` `        ``y = (y * y) % C; ` `    ``} ` `    `  `    ``// If B is odd ` `    ``else` `    ``{ ` `        ``y = A % C; ` `        ``y = (y * exponentMod(A, B - ``1``, ` `                             ``C) % C) % C; ` `    ``} ` `    `  `    ``return` `(``int``)((y + C) % C); ` `} `   `// Driver Code` `public` `static` `void` `main(String args[]) ` `{ ` `    ``int` `A = ``2``, B = ``5``, C = ``13``; ` `    ``System.out.println(``"Power is "` `+ ` `                        ``exponentMod(A, B, C)); ` `} ` `} `   `// This code is contributed ` `// by Swetank Modi. `

## Python3

 `# Recursive Python program ` `# to compute modular power ` `def` `exponentMod(A, B, C):` `    `  `    ``# Base Cases` `    ``if` `(A ``=``=` `0``):` `        ``return` `0` `    ``if` `(B ``=``=` `0``):` `        ``return` `1` `    `  `    ``# If B is Even` `    ``y ``=` `0` `    ``if` `(B ``%` `2` `=``=` `0``):` `        ``y ``=` `exponentMod(A, B ``/` `2``, C)` `        ``y ``=` `(y ``*` `y) ``%` `C` `    `  `    ``# If B is Odd` `    ``else``:` `        ``y ``=` `A ``%` `C` `        ``y ``=` `(y ``*` `exponentMod(A, B ``-` `1``, ` `                             ``C) ``%` `C) ``%` `C` `    ``return` `((y ``+` `C) ``%` `C)`   `# Driver Code` `A ``=` `2` `B ``=` `5` `C ``=` `13` `print``(``"Power is"``, exponentMod(A, B, C))` `    `  `# This code is contributed ` `# by Swetank Modi. `

## C#

 `// Recursive C# program ` `// to compute modular power ` `class` `GFG ` `{ ` `static` `int` `exponentMod(``int` `A, ``int` `B, ``int` `C) ` `{ ` `        `  `    ``// Base cases ` `    ``if` `(A == 0) ` `        ``return` `0; ` `    ``if` `(B == 0) ` `        ``return` `1; ` `    `  `    ``// If B is even ` `    ``long` `y; ` `    ``if` `(B % 2 == 0)` `    ``{ ` `        ``y = exponentMod(A, B / 2, C); ` `        ``y = (y * y) % C; ` `    ``} ` `    `  `    ``// If B is odd ` `    ``else` `    ``{ ` `        ``y = A % C; ` `        ``y = (y * exponentMod(A, B - 1, ` `                             ``C) % C) % C; ` `    ``} ` `    `  `    ``return` `(``int``)((y + C) % C); ` `} `   `// Driver Code` `public` `static` `void` `Main() ` `{ ` `    ``int` `A = 2, B = 5, C = 13; ` `    ``System.Console.WriteLine(``"Power is "` `+ ` `                    ``exponentMod(A, B, C)); ` `} ` `} `   `// This code is contributed ` `// by mits`

## PHP

 ``

## Javascript

 ``

Output:

`Power is 6`

Time Complexity : O(logn)

Auxiliary Space: O(logn)

My Personal Notes arrow_drop_up
Recommended Articles
Page :