# Solving Leetcode Interviews in Seconds with AI: Sliding Subarray Beauty


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2653" 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 containing n integers, find the beauty of each subarray of size k. The beauty of a subarray is the xth smallest integer in the subarray if it is negative, or 0 if there are fewer than x negative integers. Return an integer array containing n - k + 1 integers, which denote the beauty of the subarrays in order from the first index in the array.   A subarray is a contiguous non-empty sequence of elements within an array.     Example 1:  Input: nums = [1,-1,-3,-2,3], k = 3, x = 2 Output: [-1,-2,-2] Explanation: There are 3 subarrays with size k = 3.  The first subarray is [1, -1, -3] and the 2nd smallest negative integer is -1.  The second subarray is [-1, -3, -2] and the 2nd smallest negative integer is -2.  The third subarray is [-3, -2, 3] and the 2nd smallest negative integer is -2. Example 2:  Input: nums = [-1,-2,-3,-4,-5], k = 2, x = 2 Output: [-1,-2,-3,-4] Explanation: There are 4 subarrays with size k = 2. For [-1, -2], the 2nd smallest negative integer is -1. For [-2, -3], the 2nd smallest negative integer is -2. For [-3, -4], the 2nd smallest negative integer is -3. For [-4, -5], the 2nd smallest negative integer is -4.  Example 3:  Input: nums = [-3,1,2,-3,0,-3], k = 2, x = 1 Output: [-3,0,-3,-3,-3] Explanation: There are 5 subarrays with size k = 2. For [-3, 1], the 1st smallest negative integer is -3. For [1, 2], there is no negative integer so the beauty is 0. For [2, -3], the 1st smallest negative integer is -3. For [-3, 0], the 1st smallest negative integer is -3. For [0, -3], the 1st smallest negative integer is -3.   Constraints:  n == nums.length  1 <= n <= 105 1 <= k <= n 1 <= x <= k  -50 <= nums[i] <= 50   

	# Explanation
	Here's a breakdown of the approach, complexity, and the Python code:

*   **Key Approach:** The solution uses a sliding window technique to efficiently process each subarray of size `k`. For each window, it maintains a sorted list (using `sorted()` which leverages Timsort) of the negative numbers present in the subarray. Then, it retrieves the `x`th smallest negative number (or 0 if there are fewer than `x` negative numbers).

*   **Complexity:**
    *   **Time Complexity:** O(n * k * log(k)), where n is the length of `nums` and k is the subarray size.  This is because for each of the n-k+1 windows, we are sorting a list of at most k elements which takes O(k log k) time.
    *   **Space Complexity:** O(k), as we store at most `k` negative numbers in the `negatives` list for each subarray.

	
	# Code
	```python
	def subArrayBeauty(nums, k, x):
    """
    Calculates the beauty of each subarray of size k in the given array nums.

    Args:
        nums (list[int]): The input array of integers.
        k (int): The size of the subarray.
        x (int): The xth smallest integer to find.

    Returns:
        list[int]: An array containing the beauty of each subarray.
    """

    n = len(nums)
    result = []

    for i in range(n - k + 1):
        subarray = nums[i:i + k]
        negatives = sorted([num for num in subarray if num < 0])

        if len(negatives) >= x:
            result.append(negatives[x - 1])
        else:
            result.append(0)

    return result
	```