Find the Number of Good Pairs II - Practice Coding Problems

Find the Number of Good Pairs II - Problem

Given two integer arrays nums1 and nums2 of lengths n and m respectively, and a positive integer k, you need to find the total number of good pairs.

A pair (i, j) is considered good if nums1[i] is divisible by nums2[j] * k, where 0 ≤ i < n and 0 ≤ j < m.

Example: If nums1 = [1, 3, 4], nums2 = [1, 3, 4], and k = 1, then we check each pair to see if nums1[i] % (nums2[j] * k) == 0.

Your task is to efficiently count all such valid pairs and return the total count.

Input & Output

example_1.py — Basic Case

$ Input: nums1 = [1,3,4], nums2 = [1,3,4], k = 1

› Output: 5

💡 Note: Good pairs are: (0,0): 1%1=0, (1,0): 3%1=0, (1,1): 3%3=0, (2,0): 4%1=0, (2,2): 4%4=0

example_2.py — With Multiplier

$ Input: nums1 = [1,2,4,12], nums2 = [2,4], k = 3

› Output: 2

💡 Note: nums2*k = [6,12]. Good pairs: (2,1): 4 is not divisible by 6 or 12, (3,1): 12%12=0. Actually (3,0): 12%6=0 and (3,1): 12%12=0, so answer is 2

example_3.py — No Valid Pairs

$ Input: nums1 = [1,3], nums2 = [5,7], k = 2

› Output: 0

💡 Note: nums2*k = [10,14]. Neither 1 nor 3 is divisible by 10 or 14, so no good pairs exist

Visualization

Tap to expand

Understanding the Visualization

Inventory Count

Count how many boxes of each size and containers of each size we have

Divisor Analysis

For each box size, find all container sizes that can fit it perfectly (divisors)

Efficient Matching

Multiply the quantities: boxes × compatible_containers for each match

Key Takeaway

🎯 Key Insight: Instead of checking every individual pair, we can group identical values and use mathematical divisor relationships to count valid pairs efficiently, reducing time complexity significantly.

Time & Space Complexity

Time Complexity

⏱️

O(n + m + U*√V)

Where U is unique values in nums1, V is max value in nums1, n and m are array lengths. We build frequency maps in O(n+m) and then find divisors for each unique value

✓ Linear Growth

Space Complexity

O(n + m)

Space for storing frequency maps of both arrays

⚡ Linearithmic Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 10⁶
1 ≤ k ≤ 10³
All array elements are positive integers

Asked in

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

The optimal approach uses hash table frequency counting to avoid redundant calculations. Instead of checking every pair individually, we build frequency maps and use mathematical divisor finding to efficiently count valid pairs in O(n + m + unique_values × √max_value) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n*m)	O(1)	Check every possible pair (i,j) to see if nums1[i] is divisible by nums2[j] * k
Hash Table Optimization (Optimal)	O(n + m + U*√V)	O(n + m)	Use frequency counting to avoid redundant calculations and achieve better performance

Brute Force (Nested Loops) — Algorithm Steps

Initialize a counter to 0
Loop through each index i in nums1
For each i, loop through each index j in nums2
Check if nums1[i] is divisible by nums2[j] * k
If divisible, increment the counter
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Set up nested loops to check all combinations

Check Divisibility

For each pair (i,j), test if nums1[i] % (nums2[j] * k) == 0

Count Valid Pairs

Increment counter for each valid divisibility relationship

Code -

solution.c — C

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

int goodPairs(int* nums1, int nums1Size, int* nums2, int nums2Size, int k) {
    int count = 0;
    for (int i = 0; i < nums1Size; i++) {
        for (int j = 0; j < nums2Size; j++) {
            if (nums1[i] % (nums2[j] * k) == 0) {
                count++;
            }
        }
    }
    return count;
}

int main() {
    int nums1[] = {1, 3, 4};
    int nums2[] = {1, 3, 4};
    int k = 1;
    printf("%d\n", goodPairs(nums1, 3, nums2, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*m)

We iterate through all n elements of nums1, and for each element, we iterate through all m elements of nums2

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for the counter variable

✓ Linear Space

Constraints

1 ≤ nums1.length, nums2.length ≤ 10⁵
1 ≤ nums1[i], nums2[i] ≤ 10⁶
1 ≤ k ≤ 10³
All array elements are positive integers

52.1K Views

Medium-High Frequency

~22 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