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++
// 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> |
10
Time Complexity: O(K).
Auxiliary Space: O(K)
Please Login to comment...