# Solving Leetcode Interviews in Seconds with AI: Count Complete Subarrays in an Array


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2799" 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
	> You are given an array nums consisting of positive integers. We call a subarray of an array complete if the following condition is satisfied:  The number of distinct elements in the subarray is equal to the number of distinct elements in the whole array.  Return the number of complete subarrays. A subarray is a contiguous non-empty part of an array.   Example 1:  Input: nums = [1,3,1,2,2] Output: 4 Explanation: The complete subarrays are the following: [1,3,1,2], [1,3,1,2,2], [3,1,2] and [3,1,2,2].  Example 2:  Input: nums = [5,5,5,5] Output: 10 Explanation: The array consists only of the integer 5, so any subarray is complete. The number of subarrays that we can choose is 10.    Constraints:  1 <= nums.length <= 1000 1 <= nums[i] <= 2000  

	# Explanation
	Here's a breakdown of the solution strategy and the Python code:

*   **Core Idea:** Iterate through the array using a sliding window approach. For each starting position of the window, expand the window to the right until it becomes a "complete" subarray. Once complete, count all the subarrays starting from that position.
*   **Distinct Element Tracking:** Use a dictionary to efficiently track the frequency of elements within the current window.
*   **Optimization:** Shrink the window from the left while it remains a complete subarray, maximizing the count of complete subarrays starting from the initial window start position.

*   **Time & Space Complexity:** O(n), O(n) where n is the length of the input array, nums.

	
	# Code
	```python
	def countCompleteSubarrays(nums):
    n = len(nums)
    distinct_count = len(set(nums))
    count = 0

    for i in range(n):
        freq = {}
        distinct_in_window = 0
        for j in range(i, n):
            if nums[j] not in freq:
                freq[nums[j]] = 0
                distinct_in_window += 1
            freq[nums[j]] += 1

            if distinct_in_window == distinct_count:
                count += (n - j)
                break  # Optimization: Once complete, count and move to next i

    return count
	```