Consider below simple method to multiply two numbers.
C
#define ll long long
ll multiply(ll a, ll b, ll mod)
{
return ((a % mod) * (b % mod)) % mod;
}
|
Java
static long multiply(long a, long b, long mod)
{
return ((a % mod) * (b % mod)) % mod;
}
|
Javascript
<script>
function multiply(a,b,mod)
{
return ((a % mod) * (b % mod)) % mod;
}
</script>
|
The above function works fine when multiplication doesn’t result in overflow. But if input numbers are such that the result of multiplication is more than maximum limit.
For example, the above method fails when mod = 1011, a = 9223372036854775807 (largest long long int) and b = 9223372036854775807 (largest long long int). Note that there can be smaller values for which it may fail. There can be many more examples of smaller values. In fact any set of values for which multiplication can cause a value greater than maximum limit.
How to avoid overflow?
We can multiply recursively to overcome the difficulty of overflow. To multiply a*b, first calculate a*b/2 then add it twice. For calculating a*b/2 calculate a*b/4 and so on (similar to log n exponentiation algorithm).
// To compute (a * b) % mod
multiply(a, b, mod)
1) ll res = 0; // Initialize result
2) a = a % mod.
3) While (b > 0)
a) If b is odd, then add 'a' to result.
res = (res + a) % mod
b) Multiply 'a' with 2
a = (a * 2) % mod
c) Divide 'b' by 2
b = b/2
4) Return res Below is the implementation.
C++
#include<iostream>
using namespace std;
typedef long long int ll;
ll mulmod(ll a, ll b, ll mod)
{
ll res = 0;
a = a % mod;
while (b > 0)
{
if (b % 2 == 1)
res = (res + a) % mod;
a = (a * 2) % mod;
b /= 2;
}
return res % mod;
}
int main()
{
ll a = 9223372036854775807, b = 9223372036854775807;
cout << mulmod(a, b, 100000000000);
return 0;
}
|
Java
class GFG
{
static long mulmod(long a, long b,
long mod)
{
long res = 0;
a = a % mod;
while (b > 0)
{
if (b % 2 == 1)
{
res = (res + a) % mod;
}
a = (a * 2) % mod;
b /= 2;
}
return res % mod;
}
public static void main(String[] args)
{
long a = 9223372036854775807L, b = 9223372036854775807L;
System.out.println(mulmod(a, b, 100000000000L));
}
}
|
Python3
def mulmod(a, b, mod):
res = 0;
a = a % mod;
while (b > 0):
if (b % 2 == 1):
res = (res + a) % mod;
a = (a * 2) % mod;
b //= 2;
return res % mod;
a = 9223372036854775807;
b = 9223372036854775807;
print(mulmod(a, b, 100000000000));
|
C#
using System;
class GFG
{
static long mulmod(long a, long b, long mod)
{
long res = 0;
a = a % mod;
while (b > 0)
{
if (b % 2 == 1)
{
res = (res + a) % mod;
}
a = (a * 2) % mod;
b /= 2;
}
return res % mod;
}
public static void Main(String[] args)
{
long a = 9223372036854775807L,
b = 9223372036854775807L;
Console.WriteLine(mulmod(a, b, 100000000000L));
}
}
|
Output:
84232501249
Thanks to Utkarsh Trivedi for suggesting above solution.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
.png)
