# Solving Leetcode Interviews in Seconds with AI: Count Subarrays With Score Less Than K


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2302" 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
	> The score of an array is defined as the product of its sum and its length.  For example, the score of [1, 2, 3, 4, 5] is (1 + 2 + 3 + 4 + 5) * 5 = 75.  Given a positive integer array nums and an integer k, return the number of non-empty subarrays of nums whose score is strictly less than k. A subarray is a contiguous sequence of elements within an array.   Example 1:  Input: nums = [2,1,4,3,5], k = 10 Output: 6 Explanation: The 6 subarrays having scores less than 10 are: - [2] with score 2 * 1 = 2. - [1] with score 1 * 1 = 1. - [4] with score 4 * 1 = 4. - [3] with score 3 * 1 = 3.  - [5] with score 5 * 1 = 5. - [2,1] with score (2 + 1) * 2 = 6. Note that subarrays such as [1,4] and [4,3,5] are not considered because their scores are 10 and 36 respectively, while we need scores strictly less than 10. Example 2:  Input: nums = [1,1,1], k = 5 Output: 5 Explanation: Every subarray except [1,1,1] has a score less than 5. [1,1,1] has a score (1 + 1 + 1) * 3 = 9, which is greater than 5. Thus, there are 5 subarrays having scores less than 5.    Constraints:  1 <= nums.length <= 105 1 <= nums[i] <= 105 1 <= k <= 1015  

	# Explanation
	Here's the solution to the problem:

*   **Sliding Window Approach:** Use a sliding window to efficiently calculate the sum of subarrays. The window expands to the right, and contracts from the left when the score exceeds the limit `k`.

*   **Count Valid Subarrays:** For each valid window, the number of subarrays ending at the current right endpoint is simply the window's length. Accumulate these counts to find the total.

*   **Handle Integer Overflow:** Since `k` can be up to 10<sup>15</sup>, intermediate calculations (sum * length) can potentially overflow. Use 64-bit integers to prevent this.

*   **Runtime Complexity:** O(n), where n is the length of the nums array because we iterate through the array once with the sliding window.
*   **Storage Complexity:** O(1), as we use a constant amount of extra space.

	
	# Code
	```python
	def count_subarrays(nums, k):
    """
    Counts the number of non-empty subarrays of nums whose score is strictly less than k.

    Args:
        nums: A list of positive integers.
        k: An integer.

    Returns:
        The number of subarrays with score less than k.
    """

    count = 0
    left = 0
    current_sum = 0

    for right in range(len(nums)):
        current_sum += nums[right]

        while current_sum * (right - left + 1) >= k and left <= right:
            current_sum -= nums[left]
            left += 1

        count += (right - left + 1)

    return count
	```