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


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "1248" 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 array of integers nums and an integer k. A continuous subarray is called nice if there are k odd numbers on it. Return the number of nice sub-arrays.   Example 1:  Input: nums = [1,1,2,1,1], k = 3 Output: 2 Explanation: The only sub-arrays with 3 odd numbers are [1,1,2,1] and [1,2,1,1].  Example 2:  Input: nums = [2,4,6], k = 1 Output: 0 Explanation: There are no odd numbers in the array.  Example 3:  Input: nums = [2,2,2,1,2,2,1,2,2,2], k = 2 Output: 16    Constraints:  1 <= nums.length <= 50000 1 <= nums[i] <= 10^5 1 <= k <= nums.length  

	# Explanation
	Here's a breakdown of the approach, followed by the Python code:

*   **Prefix Sum of Odd Counts:** The core idea is to transform the problem into counting subarrays where the difference between the number of odd numbers encountered at two indices equals `k`. We can maintain a prefix sum array where each element represents the cumulative count of odd numbers up to that index in the original array.
*   **Hash Map for Efficient Counting:** Use a hash map (dictionary in Python) to store the frequency of each prefix sum value. When we encounter a prefix sum `prefix_sum`, we check how many times `prefix_sum - k` has appeared before. This count gives us the number of subarrays ending at the current index with exactly `k` odd numbers.
*   **Sliding Window (Alternative but generally less efficient):** While a sliding window approach *could* be used, the prefix sum + hashmap is generally more performant, especially when the number of even numbers is large, as it avoids repeated iterations and window adjustments.

*   **Runtime & Storage Complexity:** O(n), O(n)

	
	# Code
	```python
	def numberOfSubarrays(nums, k):
    """
    Counts the number of "nice" subarrays in the given array.

    A "nice" subarray is defined as a continuous subarray containing exactly k odd numbers.

    Args:
    nums: A list of integers.
    k: An integer representing the required number of odd numbers in a subarray.

    Returns:
    The number of nice subarrays in nums.
    """

    prefix_sums = {0: 1}  # Initialize with 0:1 to handle cases starting from index 0
    current_sum = 0
    count = 0

    for num in nums:
        if num % 2 != 0:  # Check if the number is odd
            current_sum += 1

        diff = current_sum - k
        if diff in prefix_sums:
            count += prefix_sums[diff]

        if current_sum in prefix_sums:
            prefix_sums[current_sum] += 1
        else:
            prefix_sums[current_sum] = 1

    return count
	```