 Open in App
Not now

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

• Difficulty Level : Expert
• Last Updated : 15 Jun, 2022

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

Auxiliary Space: O(K)

My Personal Notes arrow_drop_up
Related Articles