Count the Number of Good Subarrays - Practice Coding Problems

Count the Number of Good Subarrays - Problem

You're given an integer array nums and an integer k. Your task is to count how many good subarrays exist in the array.

A subarray is considered good if it contains at least k pairs of indices (i, j) where i < j and nums[i] == nums[j]. In other words, you need at least k pairs of duplicate elements within the subarray.

Key Points:

A subarray is a contiguous sequence of elements
We're counting pairs of equal elements at different positions
The pairs must satisfy i < j (left element comes before right element)
We need at least k such pairs for a subarray to be good

Example: In array [1,1,1] with k=1, the subarray [1,1,1] has 3 pairs: (0,1), (0,2), (1,2) - so it's definitely good!

Input & Output

example_1.py — Basic case

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

› Output: 3

💡 Note: The subarrays [1,1], [1,1], and [1,1,1] each have at least 1 pair of equal elements. Subarray [1,1,1] has 3 pairs: (0,1), (0,2), (1,2).

example_2.py — Mixed elements

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

› Output: 4

💡 Note: Good subarrays need at least 2 pairs. Examples include [3,1,4,3,2,2] with pairs of 3's and 2's, and longer subarrays containing these pairs.

example_3.py — No good subarrays

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

› Output: 0

💡 Note: All elements are unique, so no pairs exist. No subarray can have at least 1 pair of equal elements.

Visualization

Tap to expand

Understanding the Visualization

Expand the Party

Add a new person to the right side of our group

Count New Handshakes

New handshakes = number of people already in group with same name

Check if Party is Good

If total handshakes >= k, this group and all larger groups are good

Shrink if Needed

Remove people from left to optimize our counting

Key Takeaway

🎯 Key Insight: The sliding window approach transforms a complex O(n³) problem into an elegant O(n) solution by intelligently tracking pair formation!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is visited at most twice (once by right pointer, once by left)

✓ Linear Growth

Space Complexity

O(n)

Hash map stores frequency of unique elements in current window

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ nums.length * (nums.length - 1) / 2
Time limit: 2 seconds

Asked in

G Google 45 f Meta 38 a Amazon 32 ⊞ Microsoft 28

The optimal solution uses a sliding window technique with a hash map to track element frequencies. The key insight is that when adding an element to the window, the number of new pairs formed equals the current frequency of that element. This achieves O(n) time complexity compared to the brute force O(n³) approach.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Map (Optimal)	O(n)	O(n)	Use sliding window technique with frequency counting to efficiently track pairs
Brute Force (All Subarrays)	O(n³)	O(1)	Check every possible subarray and count pairs in each

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Initialize left and right pointers, frequency map, and pair counter
Expand right pointer and update frequency map
Calculate new pairs when adding right element
If pairs >= k, count all valid subarrays ending at right
Shrink window from left when necessary

Visualization

Tap to expand

Step-by-Step Walkthrough

Expand Window

Add element to right, update frequency and pairs

Count Valid Subarrays

When pairs >= k, count all subarrays ending at current position

Shrink Window

Move left pointer to maintain optimal window size

Code -

solution.c — C

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

typedef struct {
    int key;
    int value;
    struct Node* next;
} Node;

long long countGoodSubarrays(int* nums, int numsSize, int k) {
    int left = 0;
    long long pairs = 0;
    long long result = 0;
    
    // Simple frequency array for small values
    int freq[100001] = {0};
    
    for (int right = 0; right < numsSize; right++) {
        // Add right element and calculate new pairs
        int rightVal = nums[right];
        pairs += freq[rightVal];
        freq[rightVal]++;
        
        // Shrink window if we have enough pairs
        while (pairs >= k) {
            // All subarrays from left to right are good
            result += numsSize - right;
            
            // Remove left element
            int leftVal = nums[left];
            freq[leftVal]--;
            pairs -= freq[leftVal];
            left++;
        }
    }
    
    return result;
}

int main() {
    int nums[] = {1, 1, 1};
    int k = 1;
    printf("%lld\n", countGoodSubarrays(nums, 3, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is visited at most twice (once by right pointer, once by left)

✓ Linear Growth

Space Complexity

O(n)

Hash map stores frequency of unique elements in current window

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ nums.length * (nums.length - 1) / 2
Time limit: 2 seconds

31.2K Views

Medium-High Frequency

~25 min Avg. Time

1.3K 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

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler