Count number of pairs in array having sum divisible by K | SET 2

Given an array A[] and positive integer K, the task is to count the total number of pairs in the array whose sum is divisible by K.

Examples:

Input : A[] = {2, 2, 1, 7, 5, 3}, K = 4
Output : 5
There are five pairs possible whose sum
is divisible by ‘4’ i.e., (2, 2),
(1, 7), (7, 5), (1, 3) and (5, 3)



Input : A[] = {5, 9, 36, 74, 52, 31, 42}, K = 3
Output : 7

Approach: In the previous post, an approach using hashing is discussed. In this article, another approach using hashing is discussed.

The idea is to traverse the array, find (arr[i] % k) and keep track of these values in the hash.

The stepwise algorithm is:

  1. Find x = arr[i]%k.
  2. This array element can be paired with array elements having mod value k-x. This count of array elements is stored in hash. So add that count to answer.
  3. Increment count for x in hash.
  4. In case value of x is zero, then it can be paired only with elements having 0 mod value.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to count pairs
// whose sum divisible by 'K'
#include <bits/stdc++.h>
using namespace std;
  
// Program to count pairs whose sum divisible
// by 'K'
int countKdivPairs(int A[], int n, int K)
{
    // Create a frequency array to count
    // occurrences of all remainders when
    // divided by K
    int freq[K] = { 0 };
  
    // To store count of pairs.
    int ans = 0;
  
    // Traverse the array, compute the remainder
    // and add k-remainder value hash count to ans
    for (int i = 0; i < n; i++) {
        int rem = A[i] % K;
        if (rem != 0)
            ans += freq[K - rem];
        else
            ans += freq[0];
  
        // Increment count of remainder in hash map
        freq[rem]++;
    }
  
    return ans;
}
  
// Driver code
int main()
{
  
    int A[] = { 2, 2, 1, 7, 5, 3 };
    int n = sizeof(A) / sizeof(A[0]);
    int K = 4;
    cout << countKdivPairs(A, n, K);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java Program to count pairs
// whose sum divisible by 'K'
class GFG 
{
  
// Program to count pairs whose sum divisible
// by 'K'
static int countKdivPairs(int A[], int n, int K)
{
    // Create a frequency array to count
    // occurrences of all remainders when
    // divided by K
    int []freq = new int[K];
  
    // To store count of pairs.
    int ans = 0;
  
    // Traverse the array, compute the remainder
    // and add k-remainder value hash count to ans
    for (int i = 0; i < n; i++)
    {
        int rem = A[i] % K;
        if (rem != 0)
            ans += freq[K - rem];
        else
            ans += freq[0];
  
        // Increment count of remainder in hash map
        freq[rem]++;
    }
  
    return ans;
}
  
// Driver code
public static void main(String[] args) 
{
    int A[] = { 2, 2, 1, 7, 5, 3 };
    int n = A.length;
    int K = 4;
    System.out.println(countKdivPairs(A, n, K));
}
}
  
// This code is contributed by Princi Singh

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 Program to count pairs
# whose sum divisible by 'K'
  
# Program to count pairs whose sum divisible
# by 'K'
def countKdivPairs(A, n, K):
      
    # Create a frequency array to count
    # occurrences of all remainders when
    # divided by K
    freq = [0 for i in range(K)]
  
    # To store count of pairs.
    ans = 0
  
    # Traverse the array, compute the remainder
    # and add k-remainder value hash count to ans
    for i in range(n):
        rem = A[i] % K
        if (rem != 0):
            ans += freq[K - rem]
        else:
            ans += freq[0]
  
        # Increment count of remainder in hash map
        freq[rem] += 1
  
    return ans
  
# Driver code
if __name__ == '__main__':
    A = [2, 2, 1, 7, 5, 3]
    n = len(A)
    K = 4
    print(countKdivPairs(A, n, K))
  
# This code is contributed by
# Surendra_Gangwar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# Program to count pairs
// whose sum divisible by 'K'
using System;
  
class GFG 
{
  
// Program to count pairs whose sum divisible
// by 'K'
static int countKdivPairs(int []A, int n, int K)
{
    // Create a frequency array to count
    // occurrences of all remainders when
    // divided by K
    int []freq = new int[K];
  
    // To store count of pairs.
    int ans = 0;
  
    // Traverse the array, compute the remainder
    // and add k-remainder value hash count to ans
    for (int i = 0; i < n; i++)
    {
        int rem = A[i] % K;
        if (rem != 0)
            ans += freq[K - rem];
        else
            ans += freq[0];
  
        // Increment count of remainder in hash map
        freq[rem]++;
    }
  
    return ans;
}
  
// Driver code
public static void Main(String[] args) 
{
    int []A = { 2, 2, 1, 7, 5, 3 };
    int n = A.Length;
    int K = 4;
    Console.WriteLine(countKdivPairs(A, n, K));
}
}
  
// This code contributed by Rajput-Ji

chevron_right


Output:

5

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



My Personal Notes arrow_drop_up

A Programmer and A Machine learning Enthusiast

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.