Multiply large integers under large modulo

13 Jun, 2022
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
Java
Python3
C#
PHP
Javascript
// C++ program of finding modulo multiplication#include <bits/stdc++.h> using namespace std; // Returns (a * b) % modlong 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 programint main(){    long long a = 426;    long long b = 964;    long long m = 235;    cout << moduloMultiplication(a, b, m);    return 0;} // This code is contributed// by Akanksha Rai
// C program of finding modulo multiplication#include<stdio.h> // Returns (a * b) % modlong 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 programint main(){    long long a = 10123465234878998;    long long b = 65746311545646431;    long long m = 10005412336548794;    printf("%lld", moduloMultiplication(a, b, m));    return 0;}
// Java program of finding modulo multiplicationclass GFG{     // Returns (a * b) % mod    static long moduloMultiplication(long a,                            long b, long mod)    {                 // Initialize result        long res = 0;          // Update a if it is more than        // or equal to mod        a %= mod;         while (b > 0)        {                         // If b is odd, add a with result            if ((b & 1) > 0)            {                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    public static void main(String[] args)    {        long a = 10123465234878998L;        long b = 65746311545646431L;        long m = 10005412336548794L;        System.out.print(moduloMultiplication(a, b, m));    }} // This code is contributed by Rajput-JI
# Python 3 program of finding# modulo multiplication # Returns (a * b) % moddef 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 Codea = 10123465234878998;b = 65746311545646431;m = 10005412336548794;print(moduloMultiplication(a, b, m));     # This code is contributed# by Shivi_Aggarwal
// C# program of finding modulo multiplicationusing System; class GFG{     // Returns (a * b) % modstatic long moduloMultiplication(long a,                            long b,                            long mod){    long res = 0; // Initialize result     // Update a if it is more than    // or equal to mod    a %= mod;     while (b > 0)    {        // If b is odd, add a with result        if ((b & 1) > 0)            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 codestatic void Main(){    long a = 10123465234878998;    long b = 65746311545646431;    long m = 10005412336548794;    Console.WriteLine(moduloMultiplication(a, b, m));}} // This code is contributed// by chandan_jnu
<?php//PHP program of finding// modulo multiplication // Returns (a * b) % modfunction 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?>
<script> // JavaScript program for the above approach // Returns (a * b) % modfunction moduloMultiplication(a, b, mod){         // Initialize result    let res = 0;      // Update a if it is more than    // or equal to mod    a = (a % mod);     while (b > 0)    {                 // If b is odd, add a with result        if ((b & 1) > 0)        {            res = (res + a) % mod;        }         // Here we assume that doing 2*a        // doesn't cause overflow        a = (2 * a) % mod;         b = (b >> 1); // b = b / 2    }    return res;} // Driver Codelet a = 426;let b = 964;let m = 235; document.write(moduloMultiplication(a, b, m)); // This code is contributed by code_hunt </script>
119
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 write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks. 
jit_t
Shivi_Aggarwal
Akanksha_Rai
Chandan_Kumar
Rajput-Ji
punnapavankumar9
patiencewins
code_hunt
guptashruti232
large-numbers
Modular Arithmetic
Mathematical
Mathematical
Modular Arithmetic
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Program for Fibonacci numbers
Set in C++ Standard Template Library (STL)
C++ Data Types
Write a program to print all permutations of a given string
Merge two sorted arrays
Coin Change | DP-7
Operators in C / C++
Find minimum number of coins that make a given value
Modulo 10^9+7 (1000000007)
Minimum number of jumps to reach end