Find the Number of Good Pairs I - Practice Coding Problems

Find the Number of Good Pairs I - Problem

You're given two integer arrays nums1 and nums2 with lengths n and m respectively, along with a positive integer k. Your task is to find the total number of good pairs between these arrays.

A pair (i, j) is considered good if:

0 ≤ i < n and 0 ≤ j < m
nums1[i] is divisible by nums2[j] * k

In other words, you need to count how many elements from nums1 are divisible by the product of elements from nums2 and the multiplier k.

Example: If nums1 = [1, 3, 4], nums2 = [1, 3, 4], and k = 1, then pairs like (2, 0) are good because 4 % (1 * 1) = 0.

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*1)=0, (1,1): 3%(3*1)=0, (2,0): 4%(1*1)=0, (2,1): 4%(3*1)≠0, (2,2): 4%(4*1)=0. Total = 5 pairs.

example_2.py — With Multiplier

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

› Output: 2

💡 Note: We check divisibility by nums2[j]*3: nums2*k = [6,12]. Good pairs: (3,0): 12%6=0, (3,1): 12%12=0. Total = 2 pairs.

example_3.py — No Good Pairs

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

› Output: 0

💡 Note: nums2*k = [6,8]. Neither 1 nor 2 is divisible by 6 or 8, so no good pairs exist.

Visualization

Tap to expand

Understanding the Visualization

Setup Teams

Team 1 has nums1 players, Team 2 has nums2 players (each multiplied by k)

Test Compatibility

Each player from Team 1 tests compatibility with every player from Team 2

Count Matches

A match is successful if Team 1 player's number is divisible by Team 2 player's number

Total Score

Sum up all successful matches across all possible combinations

Key Takeaway

🎯 Key Insight: For this problem, we must check every possible pairing, making the nested loop approach both simple and optimal with O(n×m) time complexity.

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

We need to check every pair between nums1 (n elements) and nums2 (m elements)

✓ 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 ≤ 50
1 ≤ nums1[i], nums2[i] ≤ 50
1 ≤ k ≤ 1000
Note: All array elements and k are positive integers

Asked in

A Amazon 25 G Google 20 ⊞ Microsoft 15 f Meta 12

This problem requires checking every possible pair between two arrays to count divisibility relationships. The brute force approach with nested loops is actually optimal here since we must examine all n×m combinations. The key insight is that nums1[i] % (nums2[j] * k) == 0 determines if a pair is good.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n * m)	O(1)	Check every pair (i,j) to see if nums1[i] is divisible by nums2[j] * k

Brute Force (Nested Loops) — Algorithm Steps

Initialize a counter to 0
For each element nums1[i] in the first array
For each element nums2[j] in the second array
Calculate nums2[j] * k
Check if nums1[i] % (nums2[j] * k) == 0
If divisible, increment the counter
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with count = 0 and prepare to check all pairs

Outer Loop

For each element in nums1, we'll check against all elements in nums2

Inner Loop

For current nums1[i], check divisibility with each nums2[j] * k

Count

Increment counter when nums1[i] % (nums2[j] * k) == 0

Code -

solution.c — C

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

int numberOfPairs(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() {
    // Parse input and call solution
    int nums1[] = {1, 3, 4};
    int nums2[] = {1, 3, 4};
    int k = 1;
    printf("%d\n", numberOfPairs(nums1, 3, nums2, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

We need to check every pair between nums1 (n elements) and nums2 (m elements)

✓ 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 ≤ 50
1 ≤ nums1[i], nums2[i] ≤ 50
1 ≤ k ≤ 1000
Note: All array elements and k are positive integers

23.4K Views

Medium Frequency

~15 min Avg. Time

845 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