Number of solutions to Modular Equations

26 May, 2022
Given A and B, the task is to find the number of possible values that X can take such that the given modular equation (A mod X) = B holds good. Here, X is also called a solution of the modular equation.
Examples: 
Input : A = 26, B = 2
Output : 6
Explanation
X can be equal to any of {3, 4, 6, 8,
12, 24} as A modulus any of these values
equals 2 i. e., (26 mod 3) = (26 mod 4) 
= (26 mod 6) = (26 mod 8) = .... = 2 

Input : 21 5
Output : 2
Explanation
X can be equal to any of {8, 16} as A modulus 
any of these values equals 5 i.e. (21 mod 
8) = (21 mod 16) = 5
If we carefully analyze the equation A mod X = B its easy to note that if (A = B) then there are infinitely many values greater than A that X can take. In the Case when (A < B), there cannot be any possible value of X for which the modular equation holds. So the only case we are left to investigate is when (A > B).So now we focus on this case in depth.Now, in this case we can use a well known relation i.e.
Dividend = Divisor * Quotient + Remainder
We are looking for all possible X i.e. Divisors given A i.e Dividend and B i.e., remainder. So, 
We can say,
A = X * Quotient + B

Let Quotient be represented as Y
∴ A = X * Y + B
A - B = X * Y

∴ To get integral values of Y, 
we need to take all X such that X divides (A - B)

∴ X is a divisor of (A - B)
So, the problem reduces to finding the divisors of (A – B) and the number of such divisors is the possible values X can take. But as we know A mod X would result in values from (0 to X – 1) we must take all such X such that X > B.Thus, we can conclude by saying that the number of divisors of (A – B) greater than B, are the all possible values X can take to satisfy A mod X = B
C++
Java
Python3
C#
PHP
Javascript
/* C++ Program to find number of possible   values of X to satisfy A mod X = B */#include <bits/stdc++.h>using namespace std; /* Returns the number of divisors of (A - B)   greater than B */int calculateDivisors(int A, int B){    int N = (A - B);    int noOfDivisors = 0;     for (int i = 1; i <= sqrt(N); i++) {         // if N is divisible by i        if ((N % i) == 0) {             // count only the divisors greater than B            if (i > B)                noOfDivisors++;             // checking if a divisor isnot counted twice            if ((N / i) != i && (N / i) > B)                noOfDivisors++;        }    }     return noOfDivisors;} /* Utility function to calculate number of all   possible values of X for which the modular   equation holds true */int numberOfPossibleWaysUtil(int A, int B){     /* if A = B there are infinitely many solutions       to equation  or we say X can take infinitely       many values > A. We return -1 in this case */    if (A == B)        return -1;     /* if A < B, there are no possible values of       X satisfying the equation */    if (A < B)        return 0;     /* the last case is when A > B, here we calculate       the number of divisors of (A - B), which are       greater than B */    int noOfDivisors = 0;    noOfDivisors = calculateDivisors(A, B);    return noOfDivisors;} /* Wrapper function for numberOfPossibleWaysUtil() */void numberOfPossibleWays(int A, int B){    int noOfSolutions = numberOfPossibleWaysUtil(A, B);     // if infinitely many solutions available    if (noOfSolutions == -1) {        cout << "For A = " << A << " and B = " << B             << ", X can take Infinitely many values"             " greater than "  << A << "\n";    }     else {        cout << "For A = " << A << " and B = " << B             << ", X can take " << noOfSolutions              << " values\n";    }} // Driver codeint main(){    int A = 26, B = 2;    numberOfPossibleWays(A, B);    A = 21, B = 5;    numberOfPossibleWays(A, B);    return 0;}
/* Java Program to find number of possible   values of X to satisfy A mod X = B */import java.lang.*; class GFG{    /* Returns the number of divisors of (A - B)       greater than B */    public static int calculateDivisors(int A, int B)    {        int N = (A - B);        int noOfDivisors = 0;         for (int i = 1; i <= Math.sqrt(N); i++)        {             // if N is divisible by i            if ((N % i) == 0)            {                 // count only the divisors greater than B                if (i > B)                    noOfDivisors++;                 // checking if a divisor isnot counted twice                if ((N / i) != i && (N / i) > B)                    noOfDivisors++;            }        }        return noOfDivisors;    }     /* Utility function to calculate number of all       possible values of X for which the modular       equation holds true */    public static int numberOfPossibleWaysUtil(int A, int B)    {        /* if A = B there are infinitely many solutions           to equation  or we say X can take infinitely           many values > A. We return -1 in this case */        if (A == B)            return -1;         /* if A < B, there are no possible values of           X satisfying the equation */        if (A < B)            return 0;         /* the last case is when A > B, here we calculate           the number of divisors of (A - B), which are           greater than B */        int noOfDivisors = 0;        noOfDivisors = calculateDivisors(A, B);        return noOfDivisors;    }     /* Wrapper function for numberOfPossibleWaysUtil() */    public static void numberOfPossibleWays(int A, int B)    {        int noOfSolutions = numberOfPossibleWaysUtil(A, B);         // if infinitely many solutions available        if (noOfSolutions == -1)        {            System.out.print("For A = " + A + " and B = " + B                             + ", X can take Infinitely many values"                             + " greater than "  + A + "\n");        }         else        {            System.out.print("For A = " + A + " and B = " + B                             + ", X can take " + noOfSolutions                             + " values\n");        }    }    // Driver program    public static void main(String[] args)    {        int A = 26, B = 2;        numberOfPossibleWays(A, B);        A = 21;        B = 5;        numberOfPossibleWays(A, B);    }}// Contributed by _omg
# Python Program to find number of possible# values of X to satisfy A mod X = Bimport math # Returns the number of divisors of (A - B)# greater than Bdef calculateDivisors (A, B):    N = A - B    noOfDivisors = 0         a = math.sqrt(N)    for i in range(1, int(a + 1)):        # if N is divisible by i        if ((N % i == 0)):            # count only the divisors greater than B            if (i > B):                noOfDivisors +=1                             # checking if a divisor isnot counted twice            if ((N / i) != i and (N / i) > B):                noOfDivisors += 1;                     return noOfDivisors     # Utility function to calculate number of all# possible values of X for which the modular# equation holds true    def numberOfPossibleWaysUtil (A, B):    # if A = B there are infinitely many solutions    # to equation  or we say X can take infinitely    # many values > A. We return -1 in this case    if (A == B):        return -1             # if A < B, there are no possible values of    # X satisfying the equation    if (A < B):        return 0             # the last case is when A > B, here we calculate    # the number of divisors of (A - B), which are    # greater than B            noOfDivisors = 0    noOfDivisors = calculateDivisors;    return noOfDivisors              # Wrapper function for numberOfPossibleWaysUtil()def numberOfPossibleWays(A, B):    noOfSolutions = numberOfPossibleWaysUtil(A, B)         #if infinitely many solutions available    if (noOfSolutions == -1):        print ("For A = " , A , " and B = " , B                , ", X can take Infinitely many values"                , " greater than "  , A)         else:        print ("For A = " , A , " and B = " , B                , ", X can take " , noOfSolutions                , " values")# main()A = 26B = 2numberOfPossibleWays(A, B)  A = 21B = 5numberOfPossibleWays(A, B) # Contributed by _omg
/* C# Program to find number of possible   values of X to satisfy A mod X = B */using System; class GFG{    /* Returns the number of divisors of (A - B)       greater than B */    static int calculateDivisors(int A, int B)    {        int N = (A - B);        int noOfDivisors = 0;         double a = Math.Sqrt(N);        for (int i = 1; i <= (int)(a); i++)        {             // if N is divisible by i            if ((N % i) == 0)            {                 // count only the divisors greater than B                if (i > B)                    noOfDivisors++;                 // checking if a divisor isnot counted twice                if ((N / i) != i && (N / i) > B)                    noOfDivisors++;            }        }        return noOfDivisors;    }     /* Utility function to calculate number of all       possible values of X for which the modular       equation holds true */    static int numberOfPossibleWaysUtil(int A, int B)    {        /* if A = B there are infinitely many solutions           to equation  or we say X can take infinitely           many values > A. We return -1 in this case */        if (A == B)            return -1;         /* if A < B, there are no possible values of           X satisfying the equation */        if (A < B)            return 0;         /* the last case is when A > B, here we calculate           the number of divisors of (A - B), which are           greater than B */        int noOfDivisors = 0;        noOfDivisors = calculateDivisors(A, B);        return noOfDivisors;    }     /* Wrapper function for numberOfPossibleWaysUtil() */    public static void numberOfPossibleWays(int A, int B)    {        int noOfSolutions = numberOfPossibleWaysUtil(A, B);         // if infinitely many solutions available        if (noOfSolutions == -1)        {            Console.Write ("For A = " + A + " and B = " + B                           + ", X can take Infinitely many values"                           + " greater than "  + A + "\n");        }         else        {            Console.Write ("For A = " + A + " and B = " + B                           + ", X can take " + noOfSolutions                           + " values\n");        }    }     public static void Main()    {        int A = 26, B = 2;        numberOfPossibleWays(A, B);        A = 21;        B = 5;        numberOfPossibleWays(A, B);    }}// Contributed by _omg
<?php/* PHP Program to find number of possiblevalues of X to satisfy A mod X = B */ /* Returns the number of divisors of (A - B)greater than B */ function calculateDivisors($A, $B){    $N = ($A - $B);    $noOfDivisors = 0;     for ($i = 1; $i <= sqrt($N); $i++) {         // if N is divisible by i        if (($N % $i) == 0) {             // count only the divisors greater than B            if ($i > $B)                $noOfDivisors++;             // checking if a divisor isnot counted twice            if (($N / $i) != $i && ($N / $i) > $B)                $noOfDivisors++;        }    }     return $noOfDivisors;} /* Utility function to calculate number of allpossible values of X for which the modularequation holds true */function numberOfPossibleWaysUtil($A, $B){     /* if A = B there are infinitely many solutions    to equation or we say X can take infinitely    many values > A. We return -1 in this case */    if ($A == $B)        return -1;     /* if A < B, there are no possible values of    X satisfying the equation */    if ($A < $B)        return 0;     /* the last case is when A > B, here we calculate    the number of divisors of (A - B), which are    greater than B */    $noOfDivisors = 0;    $noOfDivisors = calculateDivisors($A, $B);    return $noOfDivisors;} /* Wrapper function for numberOfPossibleWaysUtil() */function numberOfPossibleWays($A, $B){    $noOfSolutions = numberOfPossibleWaysUtil($A, $B);     // if infinitely many solutions available    if ($noOfSolutions == -1) {        echo "For A = " , $A, " and B = " ,$B,            "X can take Infinitely many values            greater than " , $A , "\n";    }     else {        echo "For A = ", $A , " and B = " ,$B,            " X can take ",$noOfSolutions,            " values\n";    }} // Driver code     $A = 26; $B = 2;    numberOfPossibleWays($A, $B);    $A = 21; $B = 5;    numberOfPossibleWays($A, $B);     // This code is contributed ajit.?>
<script> // JavaScript Program to find number of possible// values of X to satisfy A mod X = B // Returns the number of divisors of (A - B)// greater than Bfunction calculateDivisors(A, B){    let N = (A - B);    let noOfDivisors = 0;       for(let i = 1; i <= Math.sqrt(N); i++)    {                 // If N is divisible by i        if ((N % i) == 0)        {                         // Count only the divisors            // greater than B            if (i > B)                noOfDivisors++;               // Checking if a divisor            // isnot counted twice            if ((N / i) != i && (N / i) > B)                noOfDivisors++;        }    }       return noOfDivisors;}   // Utility function to calculate number of all// possible values of X for which the modular// equation holds truefunction numberOfPossibleWaysUtil(A, B){         // If A = B there are infinitely many solutions    // to equation  or we say X can take infinitely    // many values > A. We return -1 in this case    if (A == B)        return -1;       // If A < B, there are no possible values of    // X satisfying the equation    if (A < B)        return 0;       // The last case is when A > B, here    // we calculate the number of divisors    // of (A - B), which are greater than B    let noOfDivisors = 0;    noOfDivisors = calculateDivisors(A, B);    return noOfDivisors;}   // Wrapper function for numberOfPossibleWaysUtil()function numberOfPossibleWays(A, B){    let noOfSolutions = numberOfPossibleWaysUtil(A, B);       // If infinitely many solutions available    if (noOfSolutions == -1)    {        document.write("For A = " + A + " and B = " +                       B + ", X can take Infinitely " +                       "many values" + " greater than " +                       A + "<br/>");    }    else    {        document.write("For A = " + A + " and B = " +                       B + ", X can take " +                       noOfSolutions + " values "  +                       "<br/>");    }} // Driver codelet A = 26, B = 2;numberOfPossibleWays(A, B); A = 21, B = 5;numberOfPossibleWays(A, B); // This code is contributed by splevel62 </script>
Output: 
For A = 26 and B = 2, X can take 6 values
For A = 21 and B = 5, X can take 2 values
Time Complexity of the above approach is nothing but the time complexity of finding the number of divisors of (A – B) ie O(√(A – B)) 
jit_t
splevel62
surinderdawra388
Modular Arithmetic
Mathematical
Technical Scripter
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)
Write a program to print all permutations of a given string
C++ Data Types
Merge two sorted arrays
Coin Change | DP-7
Operators in C / C++
Prime Numbers
Program to find GCD or HCF of two numbers
Find minimum number of coins that make a given value