用于模方程解数的Python程序

给定 A 和 B，任务是找到 X 可以取的可能值的数量，使得给定的模方程(A mod X) = B成立。这里，X 也称为模方程的解。

例子：

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

如果我们仔细分析方程 A mod X = B 很容易注意到，如果 (A = B) 则 X 可以采用无限多个大于 A 的值。在 (A < B) 的情况下，不可能有任何可能的 X 值符合模方程。所以我们唯一需要调查的情况是何时（A> B）。所以现在我们深入关注这个案例。

现在，在这种情况下，我们可以使用一个众所周知的关系，即

Dividend = Divisor * Quotient + Remainder

我们正在寻找给定 A 即股息和 B 即余数的所有可能的 X 即除数。所以，

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)

因此，问题归结为找到 (A – B) 的除数，而这些除数的数量是 X 可以取的可能值。
但是我们知道 A mod X 会产生 (0 到 X – 1) 的值，我们必须取所有这样的 X 使得 X > B。

因此，我们可以得出结论，(A – B) 大于 B 的除数数是 X 满足 A mod X = B 的所有可能值

# 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

输出：

For A = 26 and B = 2, X can take 6 values
For A = 21 and B = 5, X can take 2 values

上述方法的时间复杂度只不过是求 (A – B) 的除数个数的时间复杂度，即 O(√(A – B))

有关更多详细信息，请参阅有关模方程解数的完整文章！