Modular exponentiation (Recursive)

Given three numbers a, b and c, we need to find (a^b) % c
Now why do “% c” after exponentiation, because a^b 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 
 

// Recursive C++ program to compute modular power 
#include <bits/stdc++.h> 
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

// Recursive C program to compute modular power 
#include <stdio.h> 

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; 
} 

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

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

// 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
// Recursive PHP program to 
// compute modular power 
function exponentMod($A, $B, $C) 
{ 
    // Base cases 
    if ($A == 0) 
        return 0; 
    if ($B == 0) 
        return 1; 
    
    // If B is even 
    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; 
echo "Power is " . exponentMod($A, $B, $C); 

// This code is contributed 
// by Swetank Modi. 
?>

<script>

// Recursive Javascript program 
// to compute modular power 

// Function to check if a given 
// quadrilateral is valid or not 
function exponentMod(A, B, C) 
{ 
    
    // Base cases 
    if (A == 0) 
        return 0; 
    if (B == 0) 
        return 1; 
    
    // If B is even 
    var 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 parseInt(((y + C) % C)); 
} 

// Driver code
var A = 2, B = 5, C = 13; 
document.write("Power is " + 
               exponentMod(A, B, C)); 
    
// This code is contributed by Khushboogoyal499

</script>                    

Power is 6

Time Complexity : O(logn)

Auxiliary Space: O(logn)

Iterative modular exponentiation.