Open In App

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

Brute Force Approach: 

This is the naive approach. Here we go from 1 to N, and for each number, we check for a number in the range, on the addition of both, which gives a number divisible by k.

Steps that were to follow the above approach:

Below is the implementation of the above approach: 




// 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;
    for(int i=1;i<=N;i++)
    {
        for(int j=i+1;j<=N;j++)
        {
            if((i+j)%K==0)
            {
                count++;
            }
        }
    }
    return count;
}
 
 
// Driver code
int main()
{
    int N = 10, K = 4;
 
    // Print the count of pairs
    cout << findPairCount(N, K);
 
    return 0;
}




public class Main {
    // Function to find the number of pairs
    // from the set of natural numbers up to
    // N whose sum is divisible by K
    public static int findPairCount(int N, int K)
    {
        int count = 0;
        for (int i = 1; i <= N; i++) {
            for (int j = i + 1; j <= N; j++) {
                if ((i + j) % K == 0) {
                    count++;
                }
            }
        }
        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 Prajwal Kandekar




# Function to find the number of pairs
# from the set of natural numbers up to
# N whose sum is divisible by K
def find_pair_count(N: int, K: int) -> int:
    count = 0
    for i in range(1, N):
        for j in range(i+1, N+1):
            if (i+j) % K == 0:
                count += 1
    return count
 
# Driver code
N = 10
K = 4
 
# Print the count of pairs
print(find_pair_count(N, K))




using System;
 
class Program {
    // 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;
        for (int i = 1; i <= N; i++) {
            for (int j = i + 1; j <= N; j++) {
                if ((i + j) % K == 0) {
                    count++;
                }
            }
        }
        return count;
    }
 
    // Driver code
    static void Main(string[] args)
    {
        int N = 10, K = 4;
 
        // Print the count of pairs
        Console.WriteLine(FindPairCount(N, K));
    }
}
// This code is contributed by sarojmcy2e




// 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) {
    let count = 0;
    for (let i = 1; i <= N; i++) {
        for (let j = i + 1; j <= N; j++) {
            if ((i + j) % K === 0) {
                count++;
            }
        }
    }
    return count;
}
 
// Driver code
const N = 10,
K = 4;
 
// Print the count of pairs
console.log(findPairCount(N, K));

Output
10

Time Complexity: O(N^2)
Auxiliary Space: O(1)

Efficient Approach: An efficient approach is to use the 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: 
 

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

Algorithm:

Below is the implementation of the above approach: 
 




// 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 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 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 range(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# 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 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
?>




<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).
Auxiliary Space: O(K)
 


Article Tags :