# Number of solutions to Modular Equations

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
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

## CPP

 `/* C++ Program to find number of possible  ` `   ``values of X to satisfy A mod X = B */` `#include ` `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 isnt 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 << ````" "````; ` `    ``} ` ` `  `    ``else` `{ ` `        ``cout << ``"For A = "` `<< A << ``" and B = "` `<< B ` `             ``<< ``", X can take "` `<< noOfSolutions ` `              ``<< ````" values "````; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `A = 26, B = 2; ` `    ``numberOfPossibleWays(A, B); ` `    ``A = 21, B = 5; ` `    ``numberOfPossibleWays(A, B); ` `    ``return` `0; ` `} `

## C#

 `/* 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 isnt 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 + ````" "````); ` `        ``} ` ` `  `        ``else` `        ``{ ` `            ``Console.Write (``"For A = "` `+ A + ``" and B = "` `+ B ` `                           ``+ ``", X can take "` `+ noOfSolutions ` `                           ``+ ````" values "````); ` `        ``} ` `    ``} ` ` `  `    ``public` `static` `void` `Main() ` `    ``{ ` `        ``int` `A = 26, B = 2; ` `        ``numberOfPossibleWays(A, B); ` `        ``A = 21; ` `        ``B = 5; ` `        ``numberOfPossibleWays(A, B); ` `    ``} ` `} ` `// Contributed by _omg `

## Java

 `// Java Program to print all cube free ` `// numbers smaller than or equal to n. ` `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 isnt 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 + ````" "````); ` `        ``} ` ` `  `        ``else` `        ``{ ` `            ``System.out.print(``"For A = "` `+ A + ``" and B = "` `+ B ` `                             ``+ ``", X can take "` `+ noOfSolutions ` `                             ``+ ````" values "````); ` `        ``} ` `    ``} ` `    ``// 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 `

## Python3

 `# Python Program to find number of possible ` `# values of X to satisfy A mod X = B  ` `import` `math ` ` `  `# Returns the number of divisors of (A - B) ` `# greater than B ` `def` `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 isnt 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 ``=` `26` `B ``=` `2` `numberOfPossibleWays(A, B) ` ` `  ` `  `A ``=` `21` `B ``=` `5` `numberOfPossibleWays(A, B) ` ` `  `# Contributed by _omg `

## PHP

 ` ``\$B``) ` `                ``\$noOfDivisors``++; ` ` `  `            ``// checking if a divisor isnt 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 */` `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 , "```` "; ``` `    ``} ` ` `  `    ``else` `{ ` `        ``echo` `"For A = "``, ``\$A` `, ``" and B = "` `,``\$B``, ` `            ``" X can take "``,``\$noOfSolutions``, ` `            ````" values "````; ` `    ``} ` `} ` ` `  `// Driver code ` ` `  `    ``\$A` `= 26; ``\$B` `= 2; ` `    ``numberOfPossibleWays(``\$A``, ``\$B``); ` `    ``\$A` `= 21; ``\$B` `= 5; ` `    ``numberOfPossibleWays(``\$A``, ``\$B``); ` `     `  `// This code is contributed ajit. ` `?> `

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))

This article is attributed to GeeksforGeeks.org

code

load comments