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 = 8
Input: 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) times
Now, 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++ program to find // (a^b)%m for b very large. #include <bits/stdc++.h> #define ll long long int using namespace std;
// Function to find power ll 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 Code int 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 power static 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 Code public static void main (String[] args)
{ 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.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 power def 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 Little for 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 power static 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 Code public 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 power function 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 Little for ( $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 ?> |
// JavaScript program to find // (a^b)%m for b very large. // Function to find power function power(x, y, p)
{ let res = 1n; // Initialize result
// Update x if it is more than or
// equal to p
x = x % p;
while (y > 0n) {
// If y is odd, multiply x
// with the result
if (y & 1n)
res = (res * x) % p;
// y must be even now
y = y >> 1n; // y = y/2
x = (x * x) % p;
}
return res;
} // Driver Code let a = 3n; // String input as b is very large let b = "100000000000000000000000000" ;
let remainderB = 0n; let MOD = 1000000007n; // Reduce the number B to a small number // using Fermat Little for ( var i = 0; i < b.length; i++)
remainderB = (remainderB * 10n +
BigInt(b.charAt(i))) % (MOD - 1n);
console.log(power(a, remainderB, MOD)); // This code is contributed by phasing17 |
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.
#include <bits/stdc++.h> using namespace std;
typedef long long ll;
// Reduce the number B to a small number // using Fermat Little
ll 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;
} |
// Java program to implement the approach import java.util.*;
class GFG
{ // Reduce the number B to a small number
// using Fermat Little
static long MOD(String num, long mod)
{
long res = 0 ;
for ( int i = 0 ; i < num.length(); i++)
res = (res * 10 + num.charAt(i) - '0' )
% (mod - 1 );
return res;
}
static long ModExponent( long a, long b, long m)
{
long result;
if (a == 0 )
return 0 ;
else if (b == 0 )
return 1 ;
else if ((b & 1 ) != 0 ) {
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;
}
public static void main(String[] args)
{
long a = 3 ;
// String input as b is very large
String b = "100000000000000000000000000" ;
long m = 1000000007 ;
long remainderB = MOD(b, m);
System.out.println(ModExponent(a, remainderB, m));
}
} // This code is contributed by phasing17 |
# Python3 code to implement the approach # Reduce the number B to a small number # using Fermat Little def MOD(num, mod):
res = 0 ;
for i in range ( len (num)):
res = (res * 10 + int (num[i])) % (mod - 1 );
return res;
def ModExponent(a, b, m):
if (a = = 0 ):
return 0 ;
elif (b = = 0 ):
return 1 ;
elif (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
# Driver Code a = 3 ;
# String input as b is very large b = "100000000000000000000000000" ;
m = 1000000007 ;
remainderB = MOD(b, m);
print (ModExponent(a, remainderB, m));
# This code is contributed by phasing17 |
// C# program to implement the approach using System;
class GFG
{ // Reduce the number B to a small number
// using Fermat Little
static long MOD( string num, long mod)
{
long res = 0;
for ( int i = 0; i < num.Length; i++)
res = (res * 10 + num[i] - '0' ) % (mod - 1);
return res;
}
static long ModExponent( long a, long b, long m)
{
long result;
if (a == 0)
return 0;
else if (b == 0)
return 1;
else if ((b & 1) != 0) {
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;
}
public static void Main( string [] args)
{
long a = 3;
// String input as b is very large
string b = "100000000000000000000000000" ;
long m = 1000000007;
long remainderB = MOD(b, m);
Console.WriteLine(ModExponent(a, remainderB, m));
}
} // This code is contributed by phasing17 |
// JavaScript code to implement the approach // Reduce the number B to a small number // using Fermat Little function MOD(num, mod)
{ let res = 0n;
for (let i = 0; i < num.length; i++)
res = (res * 10n + BigInt(num.charAt(i)))
% (mod - 1n);
return res;
} function ModExponent(a, b, m)
{ let result;
if (a == 0n)
return 0n;
else if (b == 0n)
return 1n;
else if (b & 1n) {
result = a % m;
result = result * ModExponent(a, b - 1n, m);
}
else {
result = ModExponent(a, ((b - (b % 2n)) / 2n), m);
result = ((result % m) * (result % m)) % m;
}
return (result % m + m) % m;
} let a = 3n; // String input as b is very large let b = "100000000000000000000000000" ;
let m = 1000000007n; let remainderB = MOD(b, m); console.log(ModExponent(a, remainderB, m)); // This code is contributed by phasing17 |
835987331
Time Complexity: O(len(b)+log b)
Auxiliary Space: O(log b)