Related Articles

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

• Difficulty Level : Expert
• Last Updated : 31 Mar, 2021

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 :
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.

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

 ``

## Javascript

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