# Solving Leetcode Interviews in Seconds with AI: Subarrays with K Different Integers


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "992" 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 good array is an array where the number of different integers in that array is exactly k.  For example, [1,2,3,1,2] has 3 different integers: 1, 2, and 3.  A subarray is a contiguous part of an array.   Example 1:  Input: nums = [1,2,1,2,3], k = 2 Output: 7 Explanation: Subarrays formed with exactly 2 different integers: [1,2], [2,1], [1,2], [2,3], [1,2,1], [2,1,2], [1,2,1,2]  Example 2:  Input: nums = [1,2,1,3,4], k = 3 Output: 3 Explanation: Subarrays formed with exactly 3 different integers: [1,2,1,3], [2,1,3], [1,3,4].    Constraints:  1 <= nums.length <= 2 * 104 1 <= nums[i], k <= nums.length  

	# Explanation
	Here's a solution to the problem, focusing on efficiency and clarity:

*   **Problem Decomposition:** The core idea is to transform the "exactly k" problem into a "at most k" problem. We can calculate the number of subarrays with *at most* k distinct elements and then subtract the number of subarrays with *at most* (k-1) distinct elements. The difference will be the number of subarrays with *exactly* k distinct elements.

*   **Sliding Window:**  We use a sliding window approach to count the number of subarrays with at most k distinct elements. The window expands to the right, and when the number of distinct elements exceeds k, the window contracts from the left until the condition is met again.

*   **`atMost(k)` Helper:** A helper function efficiently calculates the number of "at most k" subarrays, avoiding redundant code.

*   **Time & Space Complexity:** O(n) time complexity and O(n) space complexity.

	
	# Code
	```python
	def subarraysWithKDistinct(nums, k):
    """
    Calculates the number of good subarrays of nums (subarrays with exactly k distinct integers).

    Args:
    nums (List[int]): An integer array.
    k (int): An integer representing the desired number of distinct integers in a good subarray.

    Returns:
    int: The number of good subarrays of nums.
    """

    def atMost(k):
        """
        Calculates the number of subarrays with at most k distinct elements.

        Args:
        k (int): The maximum number of distinct elements allowed in a subarray.

        Returns:
        int: The number of subarrays with at most k distinct elements.
        """
        if k < 0:
            return 0

        count = 0
        left = 0
        distinct_count = 0
        freq = {}  # Store frequency of elements within the sliding window

        for right in range(len(nums)):
            num = nums[right]
            if num not in freq:
                freq[num] = 0
                distinct_count += 1
            freq[num] += 1

            while distinct_count > k:
                left_num = nums[left]
                freq[left_num] -= 1
                if freq[left_num] == 0:
                    del freq[left_num]
                    distinct_count -= 1
                left += 1

            count += right - left + 1

        return count

    return atMost(k) - atMost(k - 1)
	```