# Number of pairs from the first N natural numbers whose sum is divisible by K

Given the integer values of N and K. The task is to find the number of pairs from the set of natural numbers up to N{1, 2, 3……N-1, N} whose sum is divisible by K.

Note : 1 <= K <= N <= 10^6.

Examples:

Input : N = 10, K = 5
Output : 9
Explanation : The possible pairs whose sum is divisible by 5 are (1, 4), (1, 9), (6, 4), (6, 9), (2, 3), (2, 8), (3, 7), (7, 8) and (5, 10). Hence the count is 9.

Input : N = 7, K = 3
Output :
Explanation : The possible pairs whose sum is divisible by 3 are (1, 2), (1, 5), (2, 4), (2, 7), (3, 6), (4, 5) and (5, 7). Hence the count is 7.

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

Simple Approach: A naive approach is to use a nested loop and check for all possible pairs and its divisibility by K. The time complexity of such an approach is O(N^2) which is not very efficient.

Efficient Approach: An efficient approach is to use basic Hashing technique.

Firstly, create array rem[K], where rem[i] contains the count of integers from 1 to N which gives the remainder i when divided by K. rem[i] can be calculated by the formula rem[i] = (N – i)/K + 1.

Secondly, the sum of two integers is divisible by K if:

• Both the integers are divisible by K. The count of which is calculated by rem*(rem-1)/2.
• Remainder of first integer is R and remainder of other number is K-R. The count of which is calculated by rem[R]*rem[K-R], where R varies from 1 to K/2.
• K is even and both the remainders are K/2. The count of which is calculated by rem[K/2]*(rem[K/2]-1)/2.

The sum of counts of all these cases gives the required count of pairs such that their sum is divisible by K.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to  find  the number of pairs ` `// from the set of natural numbers up to ` `// N whose sum is divisible by K ` `int` `findPairCount(``int` `N, ``int` `K) ` `{ ` `    ``int` `count = 0; ` ` `  `    ``// Declaring a Hash to store count ` `    ``int` `rem[K]; ` ` `  `    ``rem = N / K; ` ` `  `    ``// Storing the count of integers with ` `    ``// a specific remainder in Hash array ` `    ``for` `(``int` `i = 1; i < K; i++) ` `        ``rem[i] = (N - i) / K + 1; ` ` `  `    ``// Check if K is even ` `    ``if` `(K % 2 == 0) { ` `        ``// Count of pairs when both ` `        ``// integers are divisible by K ` `        ``count += (rem * (rem - 1)) / 2; ` ` `  `        ``// Count of pairs when one remainder ` `        ``// is R and other remainder is K - R ` `        ``for` `(``int` `i = 1; i < K / 2; i++) ` `            ``count += rem[i] * rem[K - i]; ` ` `  `        ``// Count of pairs when both the ` `        ``// remainders are K / 2 ` `        ``count += (rem[K / 2] * (rem[K / 2] - 1)) / 2; ` `    ``} ` `    ``else` `{ ` `        ``// Count of pairs when both ` `        ``// integers are divisible by K ` `        ``count += (rem * (rem - 1)) / 2; ` ` `  `        ``// Count of pairs when one remainder is R ` `        ``// and other remainder is K - R ` `        ``for` `(``int` `i = 1; i <= K / 2; i++) ` `            ``count += rem[i] * rem[K - i]; ` `    ``} ` ` `  `    ``return` `count; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `N = 10, K = 4; ` ` `  `    ``// Print the count of pairs ` `    ``cout << findPairCount(N, K); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach  ` `class` `GfG ` `{  ` ` `  `// Function to find the number of pairs  ` `// from the set of natural numbers up to  ` `// N whose sum is divisible by K  ` `static` `int` `findPairCount(``int` `N, ``int` `K)  ` `{  ` `    ``int` `count = ``0``;  ` ` `  `    ``// Declaring a Hash to store count  ` `    ``int` `rem[] = ``new` `int``[K];  ` ` `  `    ``rem[``0``] = N / K;  ` ` `  `    ``// Storing the count of integers with  ` `    ``// a specific remainder in Hash array  ` `    ``for` `(``int` `i = ``1``; i < K; i++)  ` `        ``rem[i] = (N - i) / K + ``1``;  ` ` `  `    ``// Check if K is even  ` `    ``if` `(K % ``2` `== ``0``)  ` `    ``{  ` `        ``// Count of pairs when both  ` `        ``// integers are divisible by K  ` `        ``count += (rem[``0``] * (rem[``0``] - ``1``)) / ``2``;  ` ` `  `        ``// Count of pairs when one remainder  ` `        ``// is R and other remainder is K - R  ` `        ``for` `(``int` `i = ``1``; i < K / ``2``; i++)  ` `            ``count += rem[i] * rem[K - i];  ` ` `  `        ``// Count of pairs when both the  ` `        ``// remainders are K / 2  ` `        ``count += (rem[K / ``2``] * (rem[K / ``2``] - ``1``)) / ``2``;  ` `    ``}  ` `    ``else` `    ``{  ` `        ``// Count of pairs when both  ` `        ``// integers are divisible by K  ` `        ``count += (rem[``0``] * (rem[``0``] - ``1``)) / ``2``;  ` ` `  `        ``// Count of pairs when one remainder is R  ` `        ``// and other remainder is K - R  ` `        ``for` `(``int` `i = ``1``; i <= K / ``2``; i++)  ` `            ``count += rem[i] * rem[K - i];  ` `    ``}  ` ` `  `    ``return` `count;  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `main(String[] args)  ` `{  ` `    ``int` `N = ``10``, K = ``4``;  ` ` `  `    ``// Print the count of pairs  ` `    ``System.out.println(findPairCount(N, K));  ` `} ` `}  ` ` `  `// This code is contributed by Prerna Saini `

## Python3

 `# Python3 implementation of the approach  ` ` `  `# Function to find the number of pairs  ` `# from the set of natural numbers up to  ` `# N whose sum is divisible by K  ` `def` `findPairCount(N, K) :  ` `    ``count ``=` `0``; ` `     `  `    ``# Declaring a Hash to store count ` `    ``rem ``=` `[``0``] ``*` `K; ` `     `  `    ``rem[``0``] ``=` `N ``/``/` `K;  ` `     `  `    ``# Storing the count of integers with  ` `    ``# a specific remainder in Hash array  ` `    ``for` `i ``in` `range``(``1``, K) : ` `        ``rem[i] ``=` `(N ``-` `i) ``/``/` `K ``+` `1``; ` `         `  `    ``# Check if K is even  ` `    ``if` `(K ``%` `2` `=``=` `0``) : ` `         `  `        ``# Count of pairs when both  ` `        ``# integers are divisible by K  ` `        ``count ``+``=` `(rem[``0``] ``*` `(rem[``0``] ``-` `1``)) ``/``/` `2``;  ` `         `  `        ``# Count of pairs when one remainder  ` `        ``# is R and other remainder is K - R  ` `        ``for` `i ``in` `range``(``1``, K ``/``/` `2``) : ` `            ``count ``+``=` `rem[i] ``*` `rem[K ``-` `i];  ` `         `  `        ``# Count of pairs when both the  ` `        ``# remainders are K / 2  ` `        ``count ``+``=` `(rem[K ``/``/` `2``] ``*` `(rem[K ``/``/` `2``] ``-` `1``)) ``/``/` `2``; ` `         `  `    ``else` `: ` `         `  `        ``# Count of pairs when both  ` `        ``# integers are divisible by K  ` `        ``count ``+``=` `(rem[``0``] ``*` `(rem[``0``] ``-` `1``)) ``/``/` `2``;  ` `         `  `        ``# Count of pairs when one remainder is R  ` `        ``# and other remainder is K - R  ` `        ``for` `i ``in` `rage(``1``, K``/``/``2` `+` `1``) : ` `            ``count ``+``=` `rem[i] ``*` `rem[K ``-` `i];  ` `     `  `    ``return` `count;  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `: ` ` `  `    ``N ``=` `10` `; K ``=` `4``;  ` ` `  `    ``# Print the count of pairs  ` `    ``print``(findPairCount(N, K));  ` ` `  `# This code is contributed by Ryuga `

## C#

 `// C# implementation of the approach  ` `class` `GfG ` `{  ` ` `  `// Function to find the number of pairs  ` `// from the set of natural numbers up to  ` `// N whose sum is divisible by K  ` `static` `int` `findPairCount(``int` `N, ``int` `K)  ` `{  ` `    ``int` `count = 0;  ` ` `  `    ``// Declaring a Hash to store count  ` `    ``int``[] rem = ``new` `int``[K];  ` ` `  `    ``rem = N / K;  ` ` `  `    ``// Storing the count of integers with  ` `    ``// a specific remainder in Hash array  ` `    ``for` `(``int` `i = 1; i < K; i++)  ` `        ``rem[i] = (N - i) / K + 1;  ` ` `  `    ``// Check if K is even  ` `    ``if` `(K % 2 == 0)  ` `    ``{  ` `        ``// Count of pairs when both  ` `        ``// integers are divisible by K  ` `        ``count += (rem * (rem - 1)) / 2;  ` ` `  `        ``// Count of pairs when one remainder  ` `        ``// is R and other remainder is K - R  ` `        ``for` `(``int` `i = 1; i < K / 2; i++)  ` `            ``count += rem[i] * rem[K - i];  ` ` `  `        ``// Count of pairs when both the  ` `        ``// remainders are K / 2  ` `        ``count += (rem[K / 2] * (rem[K / 2] - 1)) / 2;  ` `    ``}  ` `    ``else` `    ``{  ` `        ``// Count of pairs when both  ` `        ``// integers are divisible by K  ` `        ``count += (rem * (rem - 1)) / 2;  ` ` `  `        ``// Count of pairs when one remainder is R  ` `        ``// and other remainder is K - R  ` `        ``for` `(``int` `i = 1; i <= K / 2; i++)  ` `            ``count += rem[i] * rem[K - i];  ` `    ``}  ` ` `  `    ``return` `count;  ` `}  ` ` `  `// Driver code  ` `static` `void` `Main()  ` `{  ` `    ``int` `N = 10, K = 4;  ` ` `  `    ``// Print the count of pairs  ` `    ``System.Console.WriteLine(findPairCount(N, K));  ` `} ` `}  ` ` `  `// This code is contributed by mits `

## PHP

 ` `

Output:

```10
```

Time Complexity: O(K).

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.