Given an integer a, b, m. Find (a * b ) mod m, where a, b may be large and their direct multiplication may cause overflow. However they are smaller than half of the maximum allowed long long int value.

**Examples:**

Input: a = 426, b = 964, m = 235 Output: 119 Explanation: (426 * 964) % 235 = 410664 % 235 = 119 Input: a = 10123465234878998, b = 65746311545646431 m = 10005412336548794 Output: 4652135769797794

A **naive** approach is to use arbitrary precision data type such as **int** in python or **Biginteger** class in Java. But that approach will not be fruitful because internal conversion of string to int and then perform operation will lead to slow down the calculations of addition and multiplications in binary number system.

**Efficient solution : ** Since a and b may be very large numbers, if we try to multiply directly then it will definitely overflow. Therefore we use the basic approach of multiplication i.e.,

a * b = a + a + … + a (b times)

So we can easily compute the value of addition (under modulo m) without any

overflow in the calculation. But if we try to add the value of **a** repeatedly up to **b** times then it will definitely timeout for the large value of b, since the time complexity of this approach would become O(b).

So we divide the above repeated steps of **a** in simpler way i.e.,

If b is even then a * b = 2 * a * (b / 2), otherwise a * b = a + a * (b - 1)

Below is the approach describing above explanation :

## C++

`// C++ program of finding modulo multiplication ` `#include<bits/stdc++.h> ` ` ` `using` `namespace` `std; ` ` ` `// Returns (a * b) % mod ` `long` `long` `moduloMultiplication(` `long` `long` `a, ` ` ` `long` `long` `b, ` ` ` `long` `long` `mod) ` `{ ` ` ` `long` `long` `res = 0; ` `// Initialize result ` ` ` ` ` `// Update a if it is more than ` ` ` `// or equal to mod ` ` ` `a %= mod; ` ` ` ` ` `while` `(b) ` ` ` `{ ` ` ` `// If b is odd, add a with result ` ` ` `if` `(b & 1) ` ` ` `res = (res + a) % mod; ` ` ` ` ` `// Here we assume that doing 2*a ` ` ` `// doesn't cause overflow ` ` ` `a = (2 * a) % mod; ` ` ` ` ` `b >>= 1; ` `// b = b / 2 ` ` ` `} ` ` ` ` ` `return` `res; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `long` `long` `a = 10123465234878998; ` ` ` `long` `long` `b = 65746311545646431; ` ` ` `long` `long` `m = 10005412336548794; ` ` ` `cout << moduloMultiplication(a, b, m); ` ` ` `return` `0; ` `} ` ` ` `// This code is contributed ` `// by Akanksha Rai ` |

*chevron_right*

*filter_none*

## C

`// C program of finding modulo multiplication ` `#include<stdio.h> ` ` ` `// Returns (a * b) % mod ` `long` `long` `moduloMultiplication(` `long` `long` `a, ` ` ` `long` `long` `b, ` ` ` `long` `long` `mod) ` `{ ` ` ` `long` `long` `res = 0; ` `// Initialize result ` ` ` ` ` `// Update a if it is more than ` ` ` `// or equal to mod ` ` ` `a %= mod; ` ` ` ` ` `while` `(b) ` ` ` `{ ` ` ` `// If b is odd, add a with result ` ` ` `if` `(b & 1) ` ` ` `res = (res + a) % mod; ` ` ` ` ` `// Here we assume that doing 2*a ` ` ` `// doesn't cause overflow ` ` ` `a = (2 * a) % mod; ` ` ` ` ` `b >>= 1; ` `// b = b / 2 ` ` ` `} ` ` ` ` ` `return` `res; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `long` `long` `a = 10123465234878998; ` ` ` `long` `long` `b = 65746311545646431; ` ` ` `long` `long` `m = 10005412336548794; ` ` ` `printf` `(` `"%lld"` `, moduloMultiplication(a, b, m)); ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

## Python 3

`# Python 3 program of finding ` `# modulo multiplication ` ` ` `# Returns (a * b) % mod ` `def` `moduloMultiplication(a, b, mod): ` ` ` ` ` `res ` `=` `0` `; ` `# Initialize result ` ` ` ` ` `# Update a if it is more than ` ` ` `# or equal to mod ` ` ` `a ` `=` `a ` `%` `mod; ` ` ` ` ` `while` `(b): ` ` ` ` ` `# If b is odd, add a with result ` ` ` `if` `(b & ` `1` `): ` ` ` `res ` `=` `(res ` `+` `a) ` `%` `mod; ` ` ` ` ` `# Here we assume that doing 2*a ` ` ` `# doesn't cause overflow ` ` ` `a ` `=` `(` `2` `*` `a) ` `%` `mod; ` ` ` ` ` `b >>` `=` `1` `; ` `# b = b / 2 ` ` ` ` ` `return` `res; ` ` ` `# Driver Code ` `a ` `=` `10123465234878998` `; ` `b ` `=` `65746311545646431` `; ` `m ` `=` `10005412336548794` `; ` `print` `(moduloMultiplication(a, b, m)); ` ` ` `# This code is contributed ` `# by Shivi_Aggarwal ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `//PHP program of finding ` `// modulo multiplication ` ` ` `// Returns (a * b) % mod ` `function` `moduloMultiplication(` `$a` `, ` `$b` `, ` `$mod` `) ` `{ ` ` ` `$res` `= 0; ` `// Initialize result ` ` ` ` ` `// Update a if it is more than ` ` ` `// or equal to mod ` ` ` `$a` `%= ` `$mod` `; ` ` ` ` ` `while` `(` `$b` `) ` ` ` `{ ` ` ` ` ` `// If b is odd, ` ` ` `// add a with result ` ` ` `if` `(` `$b` `& 1) ` ` ` `$res` `= (` `$res` `+ ` `$a` `) % ` `$mod` `; ` ` ` ` ` `// Here we assume that doing 2*a ` ` ` `// doesn't cause overflow ` ` ` `$a` `= (2 * ` `$a` `) % ` `$mod` `; ` ` ` ` ` `$b` `>>= 1; ` `// b = b / 2 ` ` ` `} ` ` ` ` ` `return` `$res` `; ` `} ` ` ` ` ` `// Driver Code ` ` ` `$a` `= 10123465234878998; ` ` ` `$b` `= 65746311545646431; ` ` ` `$m` `= 10005412336548794; ` ` ` `echo` `moduloMultiplication(` `$a` `, ` `$b` `, ` `$m` `); ` ` ` `// This oce is contributed by ajit ` `?> ` |

*chevron_right*

*filter_none*

**Output:**

4652135769797794

**Time complexity: **O(log b)

**Auxiliary space: **O(1)

**Note: **Above approach will only work if **2 * m** can be represent in standard data type otherwise it will lead to overflow.

This article is contributed by Shubham Bansal. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

## Recommended Posts:

- Multiply Large Numbers represented as Strings
- Modulo power for large numbers represented as strings
- Sum of two large numbers
- Find (a^b)%m where 'a' is very large
- Find (a^b)%m where 'b' is very large
- GCD of two numbers when one of them can be very large
- LCM of two large numbers
- Multiply two integers without using multiplication, division and bitwise operators, and no loops
- Difference of two large numbers
- Remainder with 7 for large numbers
- Divisibility by 12 for a large number
- Recursive sum of digit in n^x, where n and x are very large
- Divisible by 37 for large numbers
- Factorial of a large number
- Check if a large number is divisible by 2, 3 and 5 or not