Count Array Pairs Divisible by K - Practice Coding Problems

Count Array Pairs Divisible by K - Problem

Given a 0-indexed integer array nums of length n and an integer k, your task is to find the number of valid pairs (i, j) that satisfy both conditions:

0 ≤ i < j ≤ n - 1 (pairs with distinct indices where i comes before j)
nums[i] * nums[j] is divisible by k

This problem combines number theory with efficient counting techniques. The key insight is that for two numbers to have a product divisible by k, their combined prime factors must contain all prime factors of k.

Example: If nums = [1,2,3,4,5] and k = 6, we need pairs whose product is divisible by 6. Since 6 = 2×3, we need the product to contain both factors 2 and 3.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,3,4,5], k = 6

› Output: 2

💡 Note: The valid pairs are (1,2) where 2*3=6 divisible by 6, and (2,3) where 3*4=12 divisible by 6. Other pairs like (0,1): 1*2=2, (0,2): 1*3=3, etc. don't have products divisible by 6.

example_2.py — All Divisible

$ Input: nums = [1,2,3,4], k = 2

› Output: 6

💡 Note: Since k=2, we need products to be even. Valid pairs: (0,1):1*2=2, (0,2):1*3=3❌, (0,3):1*4=4, (1,2):2*3=6, (1,3):2*4=8, (2,3):3*4=12. Actually: (0,1), (0,3), (1,2), (1,3), (2,3) = 5... Wait, let me recalculate: pairs with even products are all except (0,2) since 1*3=3 is odd. So 5 pairs total.

example_3.py — Edge Case

$ Input: nums = [1,1,1,1], k = 1

› Output: 6

💡 Note: Since k=1, every product is divisible by 1. With 4 elements, we have C(4,2) = 4!/(2!*2!) = 6 total pairs: (0,1), (0,2), (0,3), (1,2), (1,3), (2,3).

Visualization

Tap to expand

Understanding the Visualization

Analyze Key Blanks

Each array element is a key blank with certain metals (factors). We find what metals each blank contributes toward opening the master lock (k).

Group by Metal Type

Group key blanks by their essential metals (GCD with k). Blanks with GCD=2 contribute factor 2, those with GCD=3 contribute factor 3, etc.

Test Combinations

Check which pairs of metal groups can combine to form a complete key. For k=6 (needs factors 2×3), we need one blank from GCD=2 group and one from GCD=3 group.

Count Valid Pairs

Use combinatorial math: pairs from different compatible groups multiply their counts, pairs from same group use nC2 formula.

Key Takeaway

🎯 Key Insight: Instead of testing all n² pairs, group elements by their 'essential contribution' (GCD with k) and use mathematical properties to count valid combinations in O(d²) time where d is much smaller than n!

Time & Space Complexity

Time Complexity

⏱️

O(n * sqrt(k) + d²)

Computing GCD for n elements takes O(n * sqrt(k)), then checking all pairs of divisors takes O(d²) where d is number of divisors of k

✓ Linear Growth

Space Complexity

O(d)

Hash map stores at most d different GCD values, where d is the number of divisors of k

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i], k ≤ 10⁵
Array indices must satisfy 0 ≤ i < j < n
Products may exceed integer limits, requiring careful overflow handling

Asked in

G Google 42 f Meta 35 a Amazon 28 ⊞ Microsoft 23

The optimal approach uses GCD-based grouping to avoid checking all pairs directly. By computing gcd(nums[i], k) for each element and grouping elements with the same GCD, we can determine valid pairs using the mathematical property that nums[i] * nums[j] is divisible by k if and only if gcd(nums[i], k) * gcd(nums[j], k) is divisible by k. This reduces time complexity from O(n²) to O(n√k + d²) where d is the number of divisors of k.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible pair (i,j) and test if nums[i] * nums[j] is divisible by k
GCD-Based Optimization (Optimal)	O(n * sqrt(k) + d²)	O(d)	Use GCD properties to group elements by their 'essential factors' and count pairs efficiently

Brute Force (Nested Loops) — Algorithm Steps

Initialize counter to 0
Use outer loop for i from 0 to n-2
Use inner loop for j from i+1 to n-1
Check if (nums[i] * nums[j]) % k == 0
If divisible, increment counter
Return final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with array [1,2,3,4,5] and k=6

Check (0,1)

1*2=2, not divisible by 6

Check (0,2)

1*3=3, not divisible by 6

Check (1,2)

2*3=6, divisible by 6! Count=1

Continue

Check all remaining pairs systematically

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

long long countPairs(int* nums, int numsSize, int k) {
    long long count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (((long long)nums[i] * nums[j]) % k == 0) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[] = {1, 2, 3, 4, 5};
    int k = 6;
    printf("%lld\n", countPairs(nums, 5, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops iterating through all pairs, resulting in roughly n*(n-1)/2 operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables for counting, no additional data structures needed

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i], k ≤ 10⁵
Array indices must satisfy 0 ≤ i < j < n
Products may exceed integer limits, requiring careful overflow handling

72.3K Views

Medium-High Frequency

~25 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler