Number of Good Pairs - Practice Coding Problems

Number of Good Pairs - Problem

Given an array of integers nums, your task is to count the number of "good pairs" in the array.

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

nums[i] == nums[j] (the values are equal)
i < j (the first index comes before the second)

For example, in the array [1,2,3,1,1,3], we have:

Indices 0 and 3: nums[0] = nums[3] = 1 ✓
Indices 0 and 4: nums[0] = nums[4] = 1 ✓
Indices 3 and 4: nums[3] = nums[4] = 1 ✓
Indices 2 and 5: nums[2] = nums[5] = 3 ✓

That's 4 good pairs total!

Your goal: Return the total count of good pairs in the given array.

Input & Output

example_1.py — Python

$ Input: [1,2,3,1,1,3]

› Output: 4

💡 Note: There are 4 good pairs: (0,3), (0,4), (3,4), (2,5). Each pair satisfies nums[i] == nums[j] and i < j.

example_2.py — Python

$ Input: [1,1,1,1]

› Output: 6

💡 Note: All pairs are good pairs: (0,1), (0,2), (0,3), (1,2), (1,3), (2,3). With 4 identical elements, we get 4×3/2 = 6 pairs.

example_3.py — Python

$ Input: [1,2,3]

› Output: 0

💡 Note: No two elements are equal, so there are no good pairs.

Visualization

Tap to expand

Understanding the Visualization

Start Fresh

Begin with an empty frequency counter and pairs count of 0

Process Each Element

For each element, add its current frequency to pairs count, then increment frequency

Count Incrementally

This works because the nth occurrence of a value can pair with all n-1 previous occurrences

Key Takeaway

🎯 Key Insight: Instead of comparing all pairs, we count incrementally. Each element can only pair with identical elements we've seen before, making the solution both elegant and efficient.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, with O(1) hash map operations on average

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n entries in worst case (all elements unique)

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
The array contains only positive integers

Asked in

G Google 15 a Amazon 12 ⊞ Microsoft 8 f Meta 6

The optimal solution uses a one-pass hash table approach with O(n) time complexity. As we iterate through the array, we count how many times we've seen each element before - this tells us exactly how many new pairs the current element can form. The key insight is that when we encounter the nth occurrence of a value, it can pair with all (n-1) previous occurrences.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(n)	First count frequency of each element, then calculate pairs using combinatorics
One-Pass Hash Table (Optimal)	O(n)	O(n)	Count pairs incrementally as we discover each element in a single pass
Brute Force (Nested Loops)	O(n²)	O(1)	Compare every element with every other element that comes after it

Two-Pass Hash Table — Algorithm Steps

Create a hash map to count frequency of each element
Iterate through the array once to populate the frequency map
For each element that appears n times, add n×(n-1)/2 to the result
Return the total count

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build a hash map with frequency of each element

Apply Formula

For each frequency n, add n×(n-1)/2 pairs to the result

Code -

solution.c — C

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

#define MAX_VAL 101

int numIdenticalPairs(int* nums, int numsSize) {
    // First pass: count frequency (assuming nums[i] <= 100)
    int freq[MAX_VAL] = {0};
    for (int i = 0; i < numsSize; i++) {
        freq[nums[i]]++;
    }
    
    // Second pass: calculate pairs for each frequency
    int count = 0;
    for (int i = 0; i < MAX_VAL; i++) {
        if (freq[i] > 1) {
            // n elements can form n*(n-1)/2 pairs
            count += freq[i] * (freq[i] - 1) / 2;
        }
    }
    
    return count;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    
    scanf("%c", &c); // skip '['
    while (scanf("%d", &nums[size]) == 1) {
        size++;
        scanf("%c", &c);
        if (c == ']') break;
    }
    
    printf("%d\n", numIdenticalPairs(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

First pass takes O(n) to count frequencies, second pass takes O(k) where k is number of unique elements

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n entries in worst case (all elements unique)

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
The array contains only positive integers

98.5K Views

High Frequency

~5 min Avg. Time

2.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

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler