Count Array Pairs Divisible by k

Problem statement

Given a 0-indexed integer array nums of length n and an integer k, return the number of pairs (i, j) such that:

0 <= i < j <= n - 1 and
nums[i] * nums[j] is divisible by k.

Java Approach 1 Frequency Counting

import java. util.Arrays;
import java. util.HashMap;
import java. util.Map;
import java. util.Scanner;
import java. math.BigInteger;
public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); 
        // Take user input for the array and k
System.out.print("Enter array nums (space-separated): ");
 int[] nums = Arrays.stream(scanner.nextLine().split("")).mapToInt(Integer::parseInt).toArray();
System.out.print("Enter value for k: ");
        int k = scanner.nextInt();
        // Call the countPairs Method and print the result
        Solution solution = new Solution();
        long result = solution.countPairs(nums, k); 
System.out.println("Number of pairs with gcd equal to k: " + result);

scanner.close();
    }
    //Method to count pairs with gcd equal to k
    public long countPairs(int[] nums, int k) {
        Map<Long, Long> cnt = new HashMap<>();
        long res = 0L;
        for (int x : nums) {
cnt.merge(BigInteger.valueOf(x).gcd(BigInteger.valueOf(k)).longValue(), 1L, Long::sum);
        }
        for (long x : cnt.keySet()) {
            for (long y: cnt.keySet()) {
                if (x <= y && x * y % k == 0L) {
res += x < y ? cnt.get(x) * cnt.get(y) : cnt.get(x) * (cnt.get(x) - 1L) / 2L;
                }
            }
        }
        return res;
    }
}

Output:

Code Explanation:

The above Java code aims to count pairs in an array where the greatest common divisor (gcd) of the pair's elements is equal to a given value k. It uses a Map to store the count of gcd values and iterates through the array to populate this map.
Then, it iterates through the map to find pairs with gcd equal to k and updates the result accordingly. The code employs BigInteger to calculate gcd for handling large numbers.

Time complexity:

The time complexity of the provided code is approximately O(n^2), where n is the length of the input array nums. This is due to the nested loops iterating through the cnt map.
The outer loop iterates through unique gcd values, and the inner loop compares and calculates pairs with gcd equal to k.

Space complexity:

The space complexity is O(n) as the code uses a HashMap to store gcd frequencies, and in the worst case, it could have n unique gcd values.

Drawbacks:

The code has drawbacks in terms of both time and space efficiency. It uses nested loops, resulting in a time complexity of O(n^2), which can be impractical for large inputs. Additionally, it employs a HashMap to store gcd frequencies, leading to O(n) space complexity.
The inefficient pairwise comparison in the inner loop contributes to a less optimized algorithm.

Java Approach 2 Using Combination of Counting and Combinatorics

import java. util.Arrays;
import java. util.HashMap;
import java. util.Map;
import java. util.Scanner;
import java. math.BigInteger;
public class Solution {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in); 
        // Take user input for the array and k
System.out.print("Enter array nums (space-separated): ");
        int[] nums = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        System.out.print("Enter value for k: ");
        int k = scanner.nextInt();
        // Call the countPairs Method and print the result
        Solution solution = new Solution();
        long result = solution.countPairs(nums, k); 
System.out.println("Number of pairs with gcd equal to k: " + result); 
scanner.close();
    }
    //Method to count pairs with gcd equal to k
    public long countPairs(int[] nums, int k) {
        long cnt = 0;
        long[] cntgcd = new long[k+1];
        for(int i : nums){
            int gcd = gcd(i ,k); 
cntgcd[gcd]++;
        }
        for(int i = 1; i < k ; i++){
if(cntgcd[i] == 0)continue;
            int rest = k/i;
            long subc = 0;
            if(rest <= i){ 
for(int j = 1 ; j*rest <= k ; j++){   
if(j*rest < i)continue;     
if(j*rest == i){         
subc += cntgcd[i]*(cntgcd[i]-1)/2;       
continue;
                    }   
subc += cntgcd[i]*cntgcd[j*rest];
                }
                // subc = cntgcd[i]*cntgcd[k];
            }else{
               for(int j = 1 ; j*rest <= k ; j++){ 
subc += cntgcd[i]*cntgcd[j*rest];
                }
            }
            // System.out.println(subc);
            cnt += subc;
        }
        cnt += cntgcd[k]*(cntgcd[k]-1)/2;
        // System.out.println(cnt);
        return cnt;
    }
    public int gcd(int a , int b){
        while(b!= 0){
            int t = a%b;
            a =b;
            b = t;
        }
        return a;
    }

Output:

Code explanation:

The code aims to count pairs in an array where the greatest common divisor (gcd) of the pair is equal to a given value k. It utilizes an array, cntgcd, to store frequencies of gcd values. The code iterates through the array, calculating gcd for each element, and then computes the count of pairs based on gcd values.
The approach efficiently handles different cases, such as when the gcd is less than k or when k is divisible by the gcd.

Time complexity:

The time complexity of the provided code is O(n), where n is the length of the input array nums. The code iterates through the array to calculate the gcd for each element, and later, it counts pairs based on gcd values.

Space complexity:

The space complexity is O(k), where k is the given input value. It utilizes an array, cntgcd, to store the frequencies of gcd values, contributing to the overall space complexity.

Next TopicCounting Beautiful Numbers in a Specified Range

← prev next →