# Solving Leetcode Interviews in Seconds with AI: Count the Number of Good Subarrays


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2537" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given an integer array nums and an integer k, return the number of good subarrays of nums. A subarray arr is good if there are at least k pairs of indices (i, j) such that i < j and arr[i] == arr[j]. A subarray is a contiguous non-empty sequence of elements within an array.   Example 1:  Input: nums = [1,1,1,1,1], k = 10 Output: 1 Explanation: The only good subarray is the array nums itself.  Example 2:  Input: nums = [3,1,4,3,2,2,4], k = 2 Output: 4 Explanation: There are 4 different good subarrays: - [3,1,4,3,2,2] that has 2 pairs. - [3,1,4,3,2,2,4] that has 3 pairs. - [1,4,3,2,2,4] that has 2 pairs. - [4,3,2,2,4] that has 2 pairs.    Constraints:  1 <= nums.length <= 105 1 <= nums[i], k <= 109  

	# Explanation
	Here's the breakdown of the solution:

*   **Sliding Window:** We utilize a sliding window approach to efficiently explore all possible subarrays. The window expands to the right, and we maintain a count of pairs within the current window.
*   **Pair Counting:** A hash map (dictionary in Python) tracks the frequency of each number within the current window. The number of pairs contributed by each number is calculated based on its frequency.
*   **Window Adjustment:** If the number of pairs within the window is less than `k`, the window expands to the right. If the number of pairs is greater than or equal to `k`, the window shrinks from the left until the number of pairs falls below `k`. Each time we shrink the window from the left, we know the current window range was a valid subarray, so we increment the solution count.

*   **Runtime Complexity:** O(n), **Storage Complexity:** O(m), where n is the length of the input array and m is the number of distinct elements in the input array.

	
	# Code
	```python
	def goodSubarrays(nums, k):
    """
    Calculates the number of good subarrays in the given array.

    Args:
        nums: A list of integers.
        k: The minimum number of pairs required for a subarray to be good.

    Returns:
        The number of good subarrays.
    """

    n = len(nums)
    count = 0
    left = 0
    pairs = 0
    freq = {}

    for right in range(n):
        # Add the new element to the window
        if nums[right] in freq:
            pairs -= freq[nums[right]] * (freq[nums[right]] - 1) // 2
            freq[nums[right]] += 1
            pairs += freq[nums[right]] * (freq[nums[right]] - 1) // 2

        else:
            freq[nums[right]] = 1
            pairs += freq[nums[right]] * (freq[nums[right]] - 1) // 2

        # Shrink the window if the number of pairs is greater than or equal to k
        while pairs >= k:
            count += n - right
            
            if nums[left] in freq:
                pairs -= freq[nums[left]] * (freq[nums[left]] - 1) // 2
                freq[nums[left]] -= 1
                if freq[nums[left]] > 0:
                    pairs += freq[nums[left]] * (freq[nums[left]] - 1) // 2
                else:
                    del freq[nums[left]]

            left += 1

    return count
	```