Find (a^b)%m where ‘b’ is very large

02 Feb, 2022
Given three numbers a, b and m where 1<=a, m<=10^6. Given very large ‘b’ containing up to 10^6 digits and m is a prime number, the task is to find (a^b)%m.Examples: 
Input: a = 2, b = 3, m = 17 Output: 8 2 ^ 3 % 17 = 8Input: a = 3, b = 100000000000000000000000000, m = 1000000007 Output: 835987331
Iterative Approach: According to Fermat’s little theorem and Modular Exponentiation,
a^(p-1) mod p = 1, When p is prime.
From this, as of the problem, M is prime, express A^B mod M as follows: 
A^B mod M = ( A^(M-1) * A^(M-1) *.......* A^(M-1) * A^(x) ) mod M
Where x is B mod M-1 and A ^ (M-1) continues B/(M-1) timesNow, from Fermat’s Little Theorem,  
A ^ (M-1) mod M = 1.
Hence, 
A^B mod M = ( 1 * 1 * ....... * 1 * A^(x) ) mod M
Hence mod B with M-1 to reduce the number to a smaller one and then use power() method to compute (a^b)%m. Below is the implementation of the above approach:  
C++
Java
Python3
C#
PHP
// C++ program to find// (a^b)%m for b very large.#include <bits/stdc++.h>#define ll long long intusing namespace std; // Function to find powerll power(ll x, ll y, ll p){    ll res = 1; // Initialize result     // Update x if it is more than or    // equal to p    x = x % p;     while (y > 0) {               // If y is odd, multiply x        // with the 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 Codeint main(){    ll a = 3;     // String input as b is very large    string b = "100000000000000000000000000";     ll remainderB = 0;    ll MOD = 1000000007;     // Reduce the number B to a small number    // using Fermat Little    for (int i = 0; i < b.length(); i++)        remainderB = (remainderB * 10 +                       b[i] - '0') % (MOD - 1);     cout << power(a, remainderB, MOD) << endl;    return 0;}
// Java program to find// (a^b)%m for b very large.import java.io.*; class GFG{     // Function to find powerstatic long power(long x,                  long y, long p){    long res = 1; // Initialize result     // Update x if it is more    // than or equal to p    x = x % p;     while (y > 0)    {        // If y is odd, multiply        // x with the 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 Codepublic static void main (String[] args){long a = 3; // String input as// b is very largeString b = "100000000000000000000000000"; long remainderB = 0;long MOD = 1000000007; // Reduce the number B to a small// number using Fermat Littlefor (int i = 0; i < b.length(); i++)    remainderB = (remainderB * 10 +                  b.charAt(i) - '0') %                 (MOD - 1); System.out.println(power(a, remainderB, MOD));}} // This code is contributed by anuj_67.
# Python3 program to find# (a^b)%m for b very large. # Function to find powerdef power(x, y, p):    res = 1 # Initialize result     # Update x if it is    # more than or equal to p    x = x % p     while (y > 0):                 # If y is odd, multiply        # x with the 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 Codea = 3 # String input as b# is very largeb = "100000000000000000000000000" remainderB = 0MOD = 1000000007 # Reduce the number B# to a small number# using Fermat Littlefor i in range(len(b)):    remainderB = ((remainderB * 10 +                   ord(b[i]) - 48) %                   (MOD - 1)) print(power(a, remainderB, MOD)) # This code is contributed by mits
// C# program to find// (a^b)%m for b very large.using System; class GFG{     // Function to find powerstatic long power(long x,                  long y, long p){    // Initialize result    long res = 1;     // Update x if it is more    // than or equal to p    x = x % p;     while (y > 0)    {        // If y is odd, multiply        // x with the 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 Codepublic static void Main (){    long a = 3;         // String input as    // b is very large    string b = "100000000000000000000000000";         long remainderB = 0;    long MOD = 1000000007;         // Reduce the number B to    // a small number using    // Fermat Little    for (int i = 0; i < b.Length; i++)        remainderB = (remainderB * 10 +                          b[i] - '0') %                             (MOD - 1);         Console.WriteLine(power(a, remainderB, MOD));}} // This code is contributed by anuj_67.
<?php// PHP program to find// (a^b)%m for b very large. // Function to find powerfunction power($x, $y, $p){    $res = 1; // Initialize result     // Update x if it is    // more than or equal to p    $x = $x % $p;     while ($y > 0)    {        // If y is odd, multiply        // x with the 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$a = 3; // String input as b// is very large$b = "100000000000000000000000000"; $remainderB = 0;$MOD = 1000000007; // Reduce the number B// to a small number// using Fermat Littlefor ($i = 0; $i < strlen($b); $i++)    $remainderB = ($remainderB * 10 +                   $b[$i] - '0') %                  ($MOD - 1); echo power($a, $remainderB, $MOD); // This code is contributed by mits?>
835987331

Time Complexity: O(len(b)+log b)
Auxiliary Space: O(1)
Recursive Approach: It is same to the above implementation except the fact that we have to pass each subproblem result to the backtracking recursion stack.
C++14
#include <bits/stdc++.h>using namespace std;typedef long long ll; // Reduce the number B to a small number    // using Fermat Littlell MOD(string num,int mod){    ll res=0;         for(int i=0;i<num.length();i++)    res=(res*10+num[i]-'0')%(mod-1);         return res;} ll ModExponent(ll a,ll b,ll m){    ll result;    if(a==0)    return 0;    else if(b==0)    return 1;    else if(b&1)    {        result=a%m;        result=result*ModExponent(a,b-1,m);    }    else{        result=ModExponent(a,b/2,m);        result=((result%m)*(result%m))%m;    }    return (result%m+m)%m;} int main(){    ll a = 3;    // String input as b is very large    string b = "100000000000000000000000000";    ll m = 1000000007;    ll remainderB = MOD(b,m);      cout << ModExponent(a, remainderB, m) << endl;         return 0;}
835987331

Time Complexity: O(len(b)+log b)
Auxiliary Space: O(log b)
vt_m
Mithun Kumar
arvindtraj2001
prophet1999
math
Modular Arithmetic
number-theory
Competitive Programming
Mathematical
number-theory
Mathematical
Modular Arithmetic
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.