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.

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[0]*(rem[0]-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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
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[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
int main()
{
    int N = 10, K = 4;
  
    // Print the count of pairs
    cout << findPairCount(N, K);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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[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 
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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP 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
function findPairCount($N, $K)
{
    $count = 0;
  
    // Declaring a Hash to store count
    $rem = array(0, $K, NULL);
  
    $rem[0] = intval($N / $K);
  
    // Storing the count of integers with
    // a specific remainder in Hash array
    for ($i = 1; $i < $K; $i++)
        $rem[$i] = intval(($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] * intval(($rem[0] - 1)) / 2);
  
        // Count of pairs when one remainder
        // is R and other remainder is K - R
        for ($i = 1; $i < intval($K / 2); $i++)
            $count += $rem[$i] * $rem[$K - $i];
  
        // Count of pairs when both the
        // remainders are K / 2
        $count += ($rem[intval($K / 2)] * 
                        intval(($rem[intval($K / 2)] - 1)) / 2);
    }
    else 
    {
          
        // Count of pairs when both
        // integers are divisible by K
        $count += ($rem[0] * intval(($rem[0] - 1)) / 2);
  
        // Count of pairs when one remainder is R
        // and other remainder is K - R
        for ($i = 1; $i <= intval($K / 2); $i++)
            $count += $rem[$i] * $rem[$K - $i];
    }
  
    return $count;
}
  
// Driver code
$N = 10;
$K = 4;
  
// Print the count of pairs
echo findPairCount($N, $K);
  
// This code is contributed by ita_c
?>

chevron_right


Output:

10

Time Complexity: O(K).



My Personal Notes arrow_drop_up

Coder Machine Learner Social Activist Vocalist

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.