Count Subarrays with K Disjoint Equal Pairs

For this exercise, use the callable contract below.
Given an integer array nums and a positive integer k, count contiguous subarrays that contain at least k pairwise disjoint pairs of equal values.
Each array occurrence may belong to at most one pair. Therefore, a subarray with frequencies freq[x] contains sum floor(freq[x] / 2) disjoint equal pairs.

Function
countSubarraysWithEqualPairs(nums: int[], k: int) → long

Examples
Example 1
nums = [1,1,2]
k = 1
return = 2
The qualifying subarrays are [1,1] and [1,1,2].
Example 2
nums = [1,1,1,1]
k = 2
return = 1
Only the full array contains two disjoint equal pairs.

Constraints
1 <= nums.length <= 2 * 10^5.
1 <= k <= nums.length / 2.
The answer fits in a 64-bit signed integer.

The trick: the pair count of a subarray never decreases when you extend it to the right, and never increases when you shrink it from the left. That monotonicity means two pointers work. For each right end r, find the largest left l such that nums[l..r] still has at least k pairs. Then every start from 0 to l is valid, so add l+1. Maintain a frequency map and a running pairs total. When you add a value, if its new frequency is even, pairs goes up by one. When you remove a value, if its old frequency was even, pairs goes down by one. Shrink while pairs stays at least k after removing the left element. The common pitfall is returning int instead of a 64-bit value, since the answer can reach about 2*10^10. Another is recomputing pairs from scratch each step, which is quadratic. StealthCoder is the hedge if the window shrink logic slips mid-assessment.

Drill it cold or hedge it with StealthCoder. Either way, don't walk into the OA hoping you remember the trick.