# Count of pairs from 1 to a and 1 to b whose sum is divisible by N

Given three integers a, b and N. Find the total number of distinct pairs which can be formed by selecting one integer from 1 to a and other from 1 to b, such that their sum is divisible by N.

Examples:

```Input : a = 4, b = 4, N = 4
Output : 4

Input : a = 5, b = 13, N = 3
Output : 22
```

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

Basic Approach : For a pair to be divisible by N it must contain one number from range 1 to a and other from 1 to b.
So, for this iterate over integers from 1 to a and for each integer (i), b/N numbers are there whose sum with i will be divisible by N. Also if (i%N + b%N) >= N then 1 more pair exists whose sum is divisible by N.

For example took a = 7, b = 6 and N = 4:

```Let's check for i = 3:
b/N = 6/4 = 1 => there is one integer from 1 to b,
whose sum with 3 is divisible by 4 i.e.(3, 1).
Also i%N + b%N = 3%4 + 6%4 = 3+2 = 5 > 4,
means one more integer exists from 1 to b
whose sum with 3 is divisible by 4 i.e.(3, 5).
```

Below is the implementation of the above approach:

## C++

 `// C++ implementation of above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find the distinct pairs from ` `// 1-a & 1-b such that their sum is divisible by n. ` `int` `findCountOfPairs(``int` `a, ``int` `b, ``int` `n) ` `{ ` `    ``int` `ans = 0; ` ` `  `    ``// Iterate over 1 to a to find distinct pairs ` `    ``for` `(``int` `i = 1; i <= a; i++) { ` `        ``// For each integer from 1 to a ` `        ``// b/n integers exists such that pair ` `        ``// sum is divisible by n ` `        ``ans += b / n; ` ` `  `        ``// If (i%n +b%n ) >= n one more pair is possible ` `        ``ans += (i % n + b % n) >= n ? 1 : 0; ` `    ``} ` ` `  `    ``// Return answer ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a = 5, b = 13, n = 3; ` `    ``cout << findCountOfPairs(a, b, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `class` `GFG ` `{ ` ` `  `// Function to find the distinct pairs from ` `// 1-a & 1-b such that their sum is divisible by n. ` `static` `int` `findCountOfPairs(``int` `a, ``int` `b, ``int` `n) ` `{ ` `    ``int` `ans = ``0``; ` ` `  `    ``// Iterate over 1 to a to find distinct pairs ` `    ``for` `(``int` `i = ``1``; i <= a; i++)  ` `    ``{ ` `        ``// For each integer from 1 to a ` `        ``// b/n integers exists such that pair ` `        ``// sum is divisible by n ` `        ``ans += b / n; ` ` `  `        ``// If (i%n +b%n ) >= n one more pair is possible ` `        ``ans += (i % n + b % n) >= n ? ``1` `: ``0``; ` `    ``} ` ` `  `    ``// Return answer ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args)  ` `{ ` `    ``int` `a = ``5``, b = ``13``, n = ``3``; ` `    ``System.out.println(findCountOfPairs(a, b, n)); ` `} ` `} ` ` `  `// This code has been contributed by 29AjayKumar `

## Python3

 `# Python implementation of above approach ` ` `  `# Function to find the distinct pairs from ` `# 1-a & 1-b such that their sum is divisible by n. ` `def` `findCountOfPairs(a, b, n): ` `    ``ans ``=` `0` `    ``for` `i ``in` `range``(``1``, a ``+` `1``): ` ` `  `        ``# For each integer from 1 to a ` `        ``# b/n integers exists such that pair ` `        ``# / sum is divisible by n ` `        ``ans ``+``=` `b``/``/``n ` ` `  `        ``# If (i%n +b%n ) >= n one more pair is possible ` `        ``ans ``+``=` `1` `if` `(i ``%` `n ``+` `b ``%` `n) >``=` `n ``else` `0` ` `  `    ``return` `ans ` ` `  `# Driver code ` `a ``=` `5``; b ``=` `13``; n ``=` `3` `print``(findCountOfPairs(a, b, n)) ` ` `  `# This code is contributed by Shrikant13 `

## C#

 `// C# program for the above approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` `     `  `// Function to find the distinct pairs from ` `// 1-a & 1-b such that their sum is divisible by n. ` `static` `int` `findCountOfPairs(``int` `a, ``int` `b, ``int` `n) ` `{ ` `    ``int` `ans = 0; ` ` `  `    ``// Iterate over 1 to a to find distinct pairs ` `    ``for` `(``int` `i = 1; i <= a; i++)  ` `    ``{ ` `        ``// For each integer from 1 to a ` `        ``// b/n integers exists such that pair ` `        ``// sum is divisible by n ` `        ``ans += b / n; ` ` `  `        ``// If (i%n +b%n ) >= n one more pair is possible ` `        ``ans += (i % n + b % n) >= n ? 1 : 0; ` `    ``} ` ` `  `    ``// Return answer ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `static` `public` `void` `Main () ` `{ ` `    ``int` `a = 5, b = 13, n = 3; ` `    ``Console.WriteLine(findCountOfPairs(a, b, n)); ` `} ` `} ` ` `  `// This code has been contributed by ajit. `

## PHP

 `= n one more  ` `        ``// pair is possible ` `        ``\$ans` `+= ((``\$i` `% ``\$n` `) +  ` `                 ``(``\$b` `% ``\$n``)) >= ``\$n` `? 1 : 0; ` `    ``} ` ` `  `    ``// Return answer ` `    ``return` `\$ans``; ` `} ` ` `  `// Driver code ` `\$a` `= 5; ` `\$b` `= 13; ` `\$n` `= 3; ` `echo` `findCountOfPairs(``\$a``, ``\$b``, ``\$n``); ` ` `  `// This code is contributed by akt_mit. ` `?> `

Output:

```22
```

Time complexity: O(N)

Efficient Approach : For solving the problem efficiently break it into four part and solve as:

• Each integer from range 1 to N*(a/N) will have exactly b/N integers from 1 to N*(b/N) whose sum is divisible by N.
• There exists a/N integers from range 1 to N*(a/N) which can form pair with b%N integer ranging from N*(b/N) to b.
• There exists a%N integers from range N*(a/N) to a which can form pair with b/N integer ranging from 1 to N*(b/N).
• There exists (a%N + b%N)/N integers from range N*(a/N) to a and from N*(b/N) to b which can form pair whose sum is divisible by N.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to find the distinct pairs from ` `// 1-a & 1-b such that their sum is divisible by n. ` `int` `findCountOfPairs(``int` `a, ``int` `b, ``int` `n) ` `{ ` `    ``int` `ans = 0; ` ` `  `    ``// pairs from 1 to n*(a/n) and 1 to n*(b/n) ` `    ``ans += n * (a / n) * (b / n); ` ` `  `    ``// pairs from 1 to n*(a/n) and n*(b/n) to b ` `    ``ans += (a / n) * (b % n); ` ` `  `    ``// pairs from n*(a/n) to a and 1 to n*(b/n) ` `    ``ans += (a % n) * (b / n); ` ` `  `    ``// pairs from n*(a/n) to a and  n*(b/n) to b ` `    ``ans += ((a % n) + (b % n)) / n; ` ` `  `    ``// Return answer ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `a = 5, b = 13, n = 3; ` `    ``cout << findCountOfPairs(a, b, n); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of above approach ` `import` `java.io.*; ` ` `  `class` `GFG  ` `{ ` `     `  `// Function to find the distinct pairs from ` `// 1-a & 1-b such that their sum is divisible by n. ` `static` `int` `findCountOfPairs(``int` `a, ``int` `b, ``int` `n) ` `{ ` `    ``int` `ans = ``0``; ` ` `  `    ``// pairs from 1 to n*(a/n) and 1 to n*(b/n) ` `    ``ans += n * (a / n) * (b / n); ` ` `  `    ``// pairs from 1 to n*(a/n) and n*(b/n) to b ` `    ``ans += (a / n) * (b % n); ` ` `  `    ``// pairs from n*(a/n) to a and 1 to n*(b/n) ` `    ``ans += (a % n) * (b / n); ` ` `  `    ``// pairs from n*(a/n) to a and n*(b/n) to b ` `    ``ans += ((a % n) + (b % n)) / n; ` ` `  `    ``// Return answer ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main (String[] args)  ` `{ ` `    ``int` `a = ``5``, b = ``13``, n = ``3``; ` `    ``System.out.println (findCountOfPairs(a, b, n)); ` `} ` `} ` ` `  `// This code is contributed by ajit.. `

## Python3

 `# Python 3 implementation of above approach ` ` `  `# Function to find the distinct pairs from ` `# 1-a & 1-b such that their sum is divisible by n. ` `def` `findCountOfPairs(a, b, n): ` `    ``ans ``=` `0` ` `  `    ``# pairs from 1 to n*(a/n) and 1 to n*(b/n) ` `    ``ans ``+``=` `n ``*` `int``(a ``/` `n) ``*` `int``(b ``/` `n) ` ` `  `    ``# pairs from 1 to n*(a/n) and n*(b/n) to b ` `    ``ans ``+``=` `int``(a ``/` `n) ``*` `(b ``%` `n) ` ` `  `    ``# pairs from n*(a/n) to a and 1 to n*(b/n) ` `    ``ans ``+``=` `(a ``%` `n) ``*` `int``(b ``/` `n) ` ` `  `    ``# pairs from n*(a/n) to a and n*(b/n) to b ` `    ``ans ``+``=` `int``(((a ``%` `n) ``+` `(b ``%` `n)) ``/` `n); ` ` `  `    ``# Return answer ` `    ``return` `ans ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``a ``=` `5` `    ``b ``=` `13` `    ``n ``=` `3` `    ``print``(findCountOfPairs(a, b, n)) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

## C#

 `// C# implementation of above approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` `         `  `// Function to find the distinct pairs from ` `// 1-a & 1-b such that their sum is divisible by n. ` ` `  `static` `int` `findCountOfPairs(``int` `a, ``int` `b, ``int` `n) ` `{ ` `    ``int` `ans = 0; ` ` `  `    ``// pairs from 1 to n*(a/n) and 1 to n*(b/n) ` `    ``ans += n * (a / n) * (b / n); ` ` `  `    ``// pairs from 1 to n*(a/n) and n*(b/n) to b ` `    ``ans += (a / n) * (b % n); ` ` `  `    ``// pairs from n*(a/n) to a and 1 to n*(b/n) ` `    ``ans += (a % n) * (b / n); ` ` `  `    ``// pairs from n*(a/n) to a and n*(b/n) to b ` `    ``ans += ((a % n) + (b % n)) / n; ` ` `  `    ``// Return answer ` `    ``return` `ans; ` `} ` ` `  `// Driver code ` `    ``static` `public` `void` `Main (){ ` `    ``int` `a = 5, b = 13, n = 3; ` `    ``Console.WriteLine(findCountOfPairs(a, b, n)); ` `} ` `} ` ` `  `// This code is contributed by @Tushil `

## PHP

 ` `

Output:

```22
```

Time complexity: O(1)

My Personal Notes arrow_drop_up Discovering ways to develop a plane for soaring career goals

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.