Given two numbers base and exp, we need to compute baseexp under Modulo 10^9+7
Examples:
Input : base = 2, exp = 2
Output : 4
Input : base = 5, exp = 100000
Output : 754573817
In competitions, for calculating large powers of a number we are given a modulus value(a large prime number) because as the values of
- Basic Method(Binary Exponentiation)
-
-ary method.
Binary Exponentiation
As described in this article we will be using following formula to recursively calculate (
// C++ program to compute exponential // value under modulo using binary // exponentiation. #include<iostream> using namespace std;
#define N 1000000007 // prime modulo value long int exponentiation( long int base,
long int exp )
{ if ( exp == 0)
return 1;
if ( exp == 1)
return base % N;
long int t = exponentiation(base, exp / 2);
t = (t * t) % N;
// if exponent is even value
if ( exp % 2 == 0)
return t;
// if exponent is odd value
else
return ((base % N) * t) % N;
} // Driver Code int main()
{ long int base = 5;
long int exp = 100000;
long int modulo = exponentiation(base, exp );
cout << modulo << endl;
return 0;
} // This Code is contributed by mits |
// Java program to compute exponential value under modulo // using binary exponentiation. import java.util.*;
import java.lang.*;
import java.io.*;
class exp_sq {
static long N = 1000000007L; // prime modulo value
public static void main(String[] args)
{
long base = 5 ;
long exp = 100000 ;
long modulo = exponentiation(base, exp);
System.out.println(modulo);
}
static long exponentiation( long base, long exp)
{
if (exp == 0 )
return 1 ;
if (exp == 1 )
return base % N;
long t = exponentiation(base, exp / 2 );
t = (t * t) % N;
// if exponent is even value
if (exp % 2 == 0 )
return t;
// if exponent is odd value
else
return ((base % N) * t) % N;
}
} |
# Python3 program to compute # exponential value under # modulo using binary # exponentiation. # prime modulo value N = 1000000007 ;
# Function code def exponentiation(bas, exp):
if (exp = = 0 ):
return 1 ;
if (exp = = 1 ):
return bas % N;
t = exponentiation(bas, int (exp / 2 ));
t = (t * t) % N;
# if exponent is
# even value
if (exp % 2 = = 0 ):
return t;
# if exponent is
# odd value
else :
return ((bas % N) * t) % N;
# Driver code bas = 5 ;
exp = 100000 ;
modulo = exponentiation(bas, exp);
print (modulo);
# This code is contributed # by mits |
// C# program to compute exponential // value under modulo using binary // exponentiation. using System;
class GFG {
// prime modulo value
static long N = 1000000007L;
// Driver code
public static void Main()
{
long bas = 5;
long exp = 100000;
long modulo = exponentiation(bas, exp);
Console.Write(modulo);
}
static long exponentiation( long bas, long exp)
{
if (exp == 0)
return 1;
if (exp == 1)
return bas % N;
long t = exponentiation(bas, exp / 2);
t = (t * t) % N;
// if exponent is even value
if (exp % 2 == 0)
return t;
// if exponent is odd value
else
return ((bas % N) * t) % N;
}
} // This code is contributed by nitin mittal. |
<script> // JavaScript program to compute // exponential value under // modulo using binary // exponentiation. // prime modulo value let N = 1000000007; // Function code function exponentiation(base, exp){
if (exp == 0){
return 1;
}
if (exp == 1){
return (base % N);
}
let t = exponentiation(base,exp/2);
t = ((t * t) % N);
console.log(t);
// if exponent is
// even value
if (exp % 2 == 0){
return t;
}
// if exponent is
// odd value
else {
return ((base % N) * t) % N;
}
} // Driver code let base = 5; let exp = 100000; let modulo = exponentiation(base, exp); document.write(modulo); document.write(base); // This code is contributed by Gautam goel (gautamgoel962) </script> |
<?php // PHP program to compute exponential // value under modulo using binary // exponentiation. // prime modulo value $N = 1000000007;
// Function code function exponentiation( $bas , $exp )
{ global $N ;
if ( $exp == 0)
return 1;
if ( $exp == 1)
return $bas % $N ;
$t = exponentiation( $bas ,
$exp / 2);
$t = ( $t * $t ) % $N ;
// if exponent is
// even value
if ( $exp % 2 == 0)
return $t ;
// if exponent is
// odd value
else
return (( $bas % $N ) *
$t ) % $N ;
} // Driver code $bas = 5;
$exp = 100000;
$modulo = exponentiation( $bas , $exp );
echo ( $modulo );
// This code is contributed by ajit ?> |
Output :
754573817
Time Complexity: O(log exp) since the binary exponentiation algorithm divides the exponent by 2 at each recursive call, resulting in a logarithmic number of recursive calls.
Space Complexity: O(log exp)
In this algorithm we will be expanding the exponent in base
// C++ program to compute exponential value using (2^k) // -ary method. #include<bits/stdc++.h> using namespace std;
#define N 1000000007L; // prime modulo value long exponentiation( long base, long exp )
{ long t = 1L;
while ( exp > 0)
{
// for cases where exponent
// is not an even value
if ( exp % 2 != 0)
t = (t * base) % N;
base = (base * base) % N;
exp /= 2;
}
return t % N;
} // Driver code int main()
{ long base = 5;
long exp = 100000;
long modulo = exponentiation(base, exp );
cout << (modulo);
return 0;
} // This code is contributed by Rajput-Ji |
// Java program to compute exponential value using (2^k) // -ary method. import java.util.*;
import java.lang.*;
import java.io.*;
class exp_sq {
static long N = 1000000007L; // prime modulo value
public static void main(String[] args)
{
long base = 5 ;
long exp = 100000 ;
long modulo = exponentiation(base, exp);
System.out.println(modulo);
}
static long exponentiation( long base, long exp)
{
long t = 1L;
while (exp > 0 ) {
// for cases where exponent
// is not an even value
if (exp % 2 != 0 )
t = (t * base) % N;
base = (base * base) % N;
exp /= 2 ;
}
return t % N;
}
} |
# Python3 program to compute # exponential value # using (2^k) -ary method. # prime modulo value N = 1000000007 ;
def exponentiation(bas, exp):
t = 1 ;
while (exp > 0 ):
# for cases where exponent
# is not an even value
if (exp % 2 ! = 0 ):
t = (t * bas) % N;
bas = (bas * bas) % N;
exp = int (exp / 2 );
return t % N;
# Driver Code bas = 5 ;
exp = 100000 ;
modulo = exponentiation(bas,exp);
print (modulo);
# This code is contributed # by mits |
// C# program to compute // exponential value // using (2^k) -ary method. using System;
class GFG
{ // prime modulo value static long N = 1000000007L;
static long exponentiation( long bas,
long exp)
{ long t = 1L;
while (exp > 0)
{
// for cases where exponent
// is not an even value
if (exp % 2 != 0)
t = (t * bas) % N;
bas = (bas * bas) % N;
exp /= 2;
}
return t % N;
} // Driver Code public static void Main ()
{ long bas = 5;
long exp = 100000;
long modulo = exponentiation(bas,
exp);
Console.WriteLine(modulo);
} } //This code is contributed by ajit |
// JavaScript program to compute // exponential value // using (2^k) -ary method. // prime modulo value let N = 1000000007n; function exponentiation(bas, exp)
{ let t = 1n;
while (exp > 0n)
{
// for cases where exponent
// is not an even value
if (exp % 2n != 0n)
t = (t * bas) % N;
bas = (bas * bas) % N;
exp >>= 1n;
}
return t % N;
} // Driver Code let bas = 5n; let exp = 100000n; let modulo = exponentiation(bas,exp); console.log(Number(modulo)); // This code is contributed // by phasing17 |
<?php // PHP program to compute // exponential value // using (2^k) -ary method. // prime modulo value $N = 1000000007;
function exponentiation( $bas ,
$exp )
{ global $N ;
$t = 1;
while ( $exp > 0)
{
// for cases where exponent
// is not an even value
if ( $exp % 2 != 0)
$t = ( $t * $bas ) % $N ;
$bas = ( $bas * $bas ) % $N ;
$exp = (int) $exp / 2;
}
return $t % $N ;
} // Driver Code $bas = 5;
$exp = 100000;
$modulo = exponentiation( $bas ,
$exp );
echo ( $modulo );
// This code is contributed // by ajit ?> |
Output :
754573817
Time Complexity: O(log exp)
Space Complexity: O(1)
Bit-Manipulation Method
The basic idea behind the algorithm is to use the binary representation of the exponent to compute the power in a faster way.
Specifically, if we can represent the exponent as a sum of powers of 2, then we can use the fact that x^(a+b) = x^a * x^b to compute the power.
Approach :
The steps of the algorithm are as follows :
1. Initialize a result variable to 1, and a base variable to the given base value.
2. Convert the exponent to binary format.
3. Iterate over the bits of the binary representation of the exponent, from right to left.
4. For each bit, square the current value of the base.
5. If the current bit is 1, multiply the result variable by the current value of the base.
6. Divide the exponent by 2, discarding the remainder.
7. Continue the iteration until all bits of the exponent have been processed.
8. Return the result variable modulo the given modulus value.
#include <bits/stdc++.h> using namespace std;
const long long mod = 1000000007LL; // prime modulo value
long long squareMultiply( long long base, long long exp ) {
long long b = 1LL;
long long A = base % mod;
if ( exp & 1LL) {
b = base % mod;
}
exp >>= 1LL;
while ( exp > 0) {
A = (A * A) % mod;
if ( exp & 1LL) {
b = (A * b) % mod;
}
exp >>= 1LL;
}
return b % mod;
} int main() {
long long base = 5LL;
long long exp = 100000LL;
long long modulo = squareMultiply(base, exp );
cout << modulo << endl;
return 0;
} |
// Java program to compute exponential value under modulo // using Bit Manipulation. import java.util.*;
import java.lang.*;
import java.io.*;
class exp_sq {
static long mod = 1000000007L; // prime modulo value
public static void main(String[] args)
{
long base = 5 ;
long exp = 100000 ;
long modulo = squareMultiply(base, exp);
System.out.println(modulo);
}
static long squareMultiply( long base, long exp)
{
long b = 1 ;
long A = base;
if ((exp & 1 ) == 1 ){
b = base % mod;
}
exp = (exp >> 1 );
while (exp > 0 ){
A = (A * A) % mod;
if ((exp & 1 ) == 1 ){
b = (A * b) % mod;
}
exp = (exp >> 1 );
}
return b % mod;
}
} |
mod = 1000000007
# Function to square the multiply def square_multiply(base, exp):
b = 1
A = base % mod
if exp & 1 :
b = base % mod
exp >> = 1
while exp > 0 :
A = (A * A) % mod
if exp & 1 :
b = (A * b) % mod
exp >> = 1
return b % mod
# Driver Code base = 5
exp = 100000
modulo = square_multiply(base, exp)
print (modulo)
|
using System;
public class Program {
const long mod = 1000000007L; // prime modulo value
static long squareMultiply( long baseNum, long exponent)
{
long b = 1L;
long A = baseNum % mod;
if ((exponent & 1L) == 1L) {
b = baseNum % mod;
}
exponent >>= 1;
while (exponent > 0) {
A = (A * A) % mod;
if ((exponent & 1L) == 1L) {
b = (A * b) % mod;
}
exponent >>= 1;
}
return b % mod;
}
static public void Main()
{
long baseNum = 5L;
long exponent = 100000L;
long modulo = squareMultiply(baseNum, exponent);
Console.WriteLine(modulo);
}
} |
const mod = 1000000007n; // prime modulo value (BigInt)
function squareMultiply(base, exp) {
let b = 1n; // Initialize b as BigInt
let A = base % mod;
if (exp & 1n) { // Check if exp is odd (using BigInt)
b = base % mod;
}
exp >>= 1n; // Right shift exp by 1 (using BigInt)
while (exp > 0n) {
A = (A * A) % mod;
if (exp & 1n) {
b = (A * b) % mod;
}
exp >>= 1n;
}
return b % mod;
} const base = 5n; // Initialize base as BigInt
const exp = 100000n; // Initialize exp as BigInt
const modulo = squareMultiply(base, exp); console.log(modulo.toString()); // Output the result
|
Output
754573817
Time Complexity — O( log(exp) )
Space Complexity — O(1)
Applications: Besides fast calculation of