Related Articles

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

• Last Updated : 29 Jun, 2021

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

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

## Javascript

 ``
Output:
`22`

Time complexity: O(N)

Second Approach:-  This Approach Is a little Tricky. Here we find how much pair for a multiple of  N.

First:- Keep (a<b), if not then make using swap.

Second:- Start a for loop from the lowest multiple of N and go through the multiple.

• Now Smallest element ( a ) is greater than or equally current multiple then we add ((Current_Multiple) – 1) pair to the ans.
• Now a is smaller But b is greater than or equally current multiple than we add a to the ans.
• Now if a and b both smaller than we count the remaining pair for add a – (current_multiple – b ) + 1.
• Break The Loop.

Below is the implementation of the above logic.

## 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)``{``    ``if` `(a > b)``    ``{``        ``// if first element is bigger then swap``        ``swap(a, b);``    ``}``    ``int` `temp = 1, count = 0;``    ``// count is store the number of pair.``    ``for` `(``int` `i = n; temp > 0; i += n)``    ``{``        ``// we use temp for breking a loop.``        ``if` `(a >= i)``        ``{``            ``// count when a is greater.``            ``temp = i - 1;``        ``}``        ``else` `if` `(b >= i)``        ``{``            ``// Count when a is smaller but``            ``// b is greater``            ``temp = a;``        ``}``        ``else` `if` `(i > b)``        ``{``            ``// Count when a and b both are smaller``            ``temp = a - (i - b) + 1;``        ``}``        ``if` `(temp > 0) ``//breaking condition``        ``{``            ``// For storing The pair in count.``            ``count += temp;``        ``}``    ``}``    ``// return the number of pairs.``    ``return` `count;``}` `// Driver code``int` `main()``{``    ``int` `a = 5, b = 13, n = 3;``    ``cout << findCountOfPairs(a, b, n);` `    ``return` `0;``}``// contribute by Vivek Javiya`

## Java

 `// Java implementation of``// the above approach``class` `GFG{``    ` `// Function to find the``// distinct pairs from``// 1-a & 1-b such that``// their sum is divisible by n.``public` `static` `int` `findCountOfPairs(``int` `a,``                                   ``int` `b,``                                   ``int` `n)``{``  ``if` `(a > b)``  ``{``    ``// if first element is``    ``// bigger then swap``    ``int` `temp = a;``    ``a = b;``    ``b = temp;``  ``}``  ` `  ``int` `temp = ``1``, count = ``0``;``  ` `  ``// count is store the``  ``// number of pair.``  ``for` `(``int` `i = n; temp > ``0``; i += n)``  ``{``    ``// we use temp for``    ``// breaking a loop.``    ``if` `(a >= i)``    ``{``      ``// count when a``      ``// is greater.``      ``temp = i - ``1``;``    ``}``    ``else` `if` `(b >= i)``    ``{``      ``// Count when a is``      ``// smaller but``      ``// b is greater``      ``temp = a;``    ``}``    ``else` `if` `(i > b)``    ``{``      ``// Count when a and b``      ``// both are smaller``      ``temp = a - (i - b) + ``1``;``    ``}``    ` `    ``//breaking condition``    ``if` `(temp > ``0``)``    ``{``      ``// For storing The``      ``// pair in count.``      ``count += temp;``    ``}``  ``}``  ` `  ``// return the number``  ``// of pairs.``  ``return` `count;``}``  ` `// Driver code``public` `static` `void` `main(String[] args)``{``  ``int` `a = ``5``, b = ``13``, n = ``3``;``  ``System.out.print(findCountOfPairs(a,``                                    ``b, n));``}``}` `// This code is contributed by divyeshrabadiya07`

## 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):``    ``if``(a > b):``      ` `        ``# if first element is bigger then swap``        ``a, b ``=` `b, a` `    ``temp ``=` `1``    ``count ``=` `0``    ` `    ``# count is store the number of pair.``    ``i ``=` `n``    ``while``(temp > ``0``):``      ` `        ``# we use temp for breking a loop.``        ``if``(a >``=` `i):``          ` `            ``# count when a is greater.``            ``temp ``=` `i ``-` `1``        ``elif``(b >``=` `i):``          ` `            ``# Count when a is smaller but``            ``# b is greater``            ``temp ``=` `a``        ``elif``(i > b):``          ` `            ``# Count when a and b both are smaller``            ``temp ``=` `a ``-` `(i ``-` `b) ``+` `1` `        ``if``(temp > ``0``):``          ` `          ``# breaking condition``            ``# For storing The pair in count.``            ``count ``+``=` `temp``        ``i ``+``=` `n` `    ``# return the number of pairs.``    ``return` `count` `# Driver code``a ``=` `5``b ``=` `13``n ``=` `3` `print``(findCountOfPairs(a, b, n))` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# implementation of``// 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)``    ``{``      ``if` `(a > b)``      ``{``        ` `        ``// if first element is``        ``// bigger then swap``        ``int` `temp1 = a;``        ``a = b;``        ``b = temp1;``      ``}``       ` `      ``int` `temp = 1, count = 0;``       ` `      ``// count is store the``      ``// number of pair.``      ``for` `(``int` `i = n; temp > 0; i += n)``      ``{``        ` `        ``// we use temp for``        ``// breaking a loop.``        ``if` `(a >= i)``        ``{``          ` `          ``// count when a``          ``// is greater.``          ``temp = i - 1;``        ``}``        ``else` `if` `(b >= i)``        ``{``          ` `          ``// Count when a is``          ``// smaller but``          ``// b is greater``          ``temp = a;``        ``}``        ``else` `if` `(i > b)``        ``{``          ` `          ``// Count when a and b``          ``// both are smaller``          ``temp = a - (i - b) + 1;``        ``}``         ` `        ``// breaking condition``        ``if` `(temp > 0)``        ``{``          ` `          ``// For storing The``          ``// pair in count.``          ``count += temp;``        ``}``      ``}``       ` `      ``// return the number``      ``// of pairs.``      ``return` `count;``    ``}``  ` `  ``// Driver code``  ``static` `void` `Main()``  ``{``      ``int` `a = 5, b = 13, n = 3;``      ``Console.WriteLine(findCountOfPairs(a, b, n));``  ``}``}` `// This code is contributed by divyesh072019`

## Javascript

 ``

Output :

`22`

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 exist a/N integers from range 1 to N*(a/N) which can form pairs with b%N integer ranging from N*(b/N) to b.
• There exist a%N integers from range N*(a/N) to a which can form pairs 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

 ``

## Javascript

 ``
Output:
`22`

Time complexity: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up