Open In App

Python Program for Number of solutions to Modular Equations

Improve
Improve
Like Article
Like
Save
Share
Report

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) =Output: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)

Python Program for Number of solutions to Modular Equations

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 

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 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 = 26
B = 2
numberOfPossibleWays(A, B)
 
 
A = 21
B = 5
numberOfPossibleWays(A, B)
 
# Contributed by _omg


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)) Please refer complete article on Number of solutions to Modular Equations for more details!

Method 2: 

The new approach for solving the problem of finding the number of possible values of X to satisfy A mod X = B involves:

  • Checking for special cases where the solution is either infinite or non-existent.
  • Calculating the difference between A and B, and finding all its divisors.
  • Counting the number of divisors that are greater than B.
  • Returning the count of such divisors as the number of possible values of X.

Python3




# function to calculate the number of possible values for X
def numberOfPossibleWays(A, B):
    # if A and B are equal, there are no possible values for X
    if A == B:
        return -1
    # if A is less than B, X cannot be greater than B
    elif A < B:
        return 0
    else:
        count = 0
        diff = A - B
        sqrt_diff = int(diff ** 0.5)
        # iterate over the range of square root of difference
        for i in range(1, sqrt_diff + 1):
            # check if i is a factor of the difference
            if diff % i == 0:
                # if i is greater than B, increment the count
                if i > B:
                    count += 1
                # check if the quotient is greater than B and not equal to i, then increment the count
                if diff // i != i and diff // i > B:
                    count += 1
        return count
 
# test case 1
A = 26
B = 2
print("For A =", A, "and B =", B, ", X can take", numberOfPossibleWays(A, B), "values")
 
# test case 2
A = 21
B = 5
print("For A =", A, "and B =", B, ", X can take", numberOfPossibleWays(A, B), "values")
 
# Contributed by adityasha4x71


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:  O(sqrt(A-B)), because the loop iterates from 1 to the square root of A-B. 

Auxiliary Space: O(1)



Last Updated : 27 Jul, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads