Count possible values of K such that X – 1 and Y – 1 modulo K is same

Given two numbers X and Y, the task is to find the count of integers K which satisfies the equation (X – 1) % K = (Y – 1) % K.

Examples:

Input: X = 2, Y = 6
Output: 3
Explanation:
K = {1, 2, 4} satisfies the given equation. Therefore, the count is 3.

Input: X = 4, Y = 9
Output: 2

Approach: Follow the steps below to solve the problem:

• The idea is to find the absolute difference between X and Y.
• Find the count of divisors of the calculated absolute difference and print the count as the required answer.

Below is the implementation of the above approach:

C++14

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to count integers K
// satisfying given equation
int condition(int a, int b)
{
    // Calculate the absoluter
    // difference between a and b
    int d = abs(a - b), count = 0;

    // Iterate till sqrt of the difference
    for (int i = 1; i <= sqrt(d); i++) {
        if (d % i == 0) {
            if (d / i == i)
                count += 1;
            else
                count += 2;
        }
    }

    // Return the count
    return count;
}

// Driver Code
int main()
{

    int x = 2, y = 6;
    cout << condition(x, y) << endl;

    return 0;
}

Java

// Java program for the above approach
import java.io.*;

class GFG{

// Function to count integers K
// satisfying given equation
static int condition(int a, int b)
{

    // Calculate the absoluter
    // difference between a and b
    int d = Math.abs(a - b), count = 0;

    // Iterate till sqrt of the difference
    for(int i = 1; i <= Math.sqrt(d); i++)
    {
        if (d % i == 0)
        {
            if (d / i == i)
                count += 1;
            else
                count += 2;
        }
    }

    // Return the count
    return count;
}

// Driver Code
public static void main (String[] args)
{
    int x = 2, y = 6;

    System.out.println(condition(x, y));
}
}

// This code is contributed by sanjoy_62

Python3

# Python3 program for the above approach

# Function to count integers K
# satisfying given equation
def condition(a, b):

    # Calculate the absoluter
    # difference between a and b
    d = abs(a - b)
    count = 0

    # Iterate till sqrt of the difference
    for i in range(1, d + 1):
        if i * i > d:
            break
        if (d % i == 0):
            if (d // i == i):
                count += 1
            else:
                count += 2

    # Return the count
    return count

# Driver Code
if __name__ == '__main__':

    x = 2
    y = 6

    print(condition(x, y))

# This code is contributed by mohit kumar 29

C#

// C# program for the
// above approach
using System;
class GFG{

// Function to count
// integers K satisfying
// given equation
static int condition(int a,
                     int b)
{
  // Calculate the absoluter
  // difference between a and b
  int d = Math.Abs(a - b), count = 0;

  // Iterate till sqrt of
  // the difference
  for(int i = 1;
          i <= Math.Sqrt(d); i++)
  {
    if (d % i == 0)
    {
      if (d / i == i)
        count += 1;
      else
        count += 2;
    }
  }

  // Return the count
  return count;
}

// Driver Code
public static void Main(String[] args)
{
  int x = 2, y = 6;
  Console.WriteLine(condition(x, y));
}
}

// This code is contributed by shikhasingrajput

Javascript

<script>

// Javascript program for the above approach

// Function to count integers K
// satisfying given equation
function condition(a, b)
{

    // Calculate the absoluter
    // difference between a and b
    let d = Math.abs(a - b), count = 0;

    // Iterate till sqrt of the difference
    for(let i = 1; i <= Math.sqrt(d); i++)
    {
        if (d % i == 0)
        {
            if (d / i == i)
                count += 1;
            else
                count += 2;
        }
    }

    // Return the count
    return count;
}

// Driver Code

  let x = 2, y = 6;

  document.write(condition(x, y));

</script>

Output:

3

Time Complexity: O(?abs(X – Y))
Auxiliary Space: O(1)