Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Expert
  • Last Updated : 25 Oct, 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. 
 

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.

 



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




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

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

PHP




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

Javascript




<script>
// javascript 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)
{
    var count = 0;
 
    // Declaring a Hash to store count
    var rem = Array.from({length: K}, (_, i) => 0);
 
    rem[0] = parseInt(N / K);
 
    // Storing the count of integers with
    // a specific remainder in Hash array
    for (i = 1; i < K; i++)
        rem[i] = parseInt((N - i) / K + 1);
 
    // Check if K is even
    if (K % 2 == 0)
    {
     
        // Count of pairs when both
        // integers are divisible by K
        count += parseInt((rem[0] * (rem[0] - 1)) / 2);
 
        // Count of pairs when one remainder
        // is R and other remainder is K - R
        for (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 (i = 1; i <= K / 2; i++)
            count += rem[i] * rem[K - i];
    }
    return count;
}
 
// Driver code
var N = 10, K = 4;
 
// Print the count of pairs
document.write(findPairCount(N, K));
 
// This code is contributed by Princi Singh
</script>
Output: 
10

 

Time Complexity: O(K).
 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!