Count Number of Nice Subarrays - Practice Coding Problems

Count Number of Nice Subarrays - Problem

Array Hash Table Math Sliding Window Prefix Sum Medium

You're given an array of integers nums and an integer k. Your task is to find the number of "nice" subarrays.

A subarray is considered nice if it contains exactly k odd numbers. A subarray is a contiguous sequence of elements from the array.

For example, given nums = [1, 1, 2, 1, 1] and k = 3, we need to find all subarrays that contain exactly 3 odd numbers. The subarrays [1, 1, 2, 1] and [1, 2, 1, 1] both contain exactly 3 odd numbers, so they are "nice".

Goal: Return the total count of nice subarrays in the given array.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,1,2,1,1], k = 3

› Output: 2

💡 Note: The nice subarrays are [1,1,2,1] and [1,2,1,1]. Both contain exactly 3 odd numbers.

example_2.py — Single Element

$ Input: nums = [2,4,6], k = 1

› Output: 0

💡 Note: All numbers are even, so no subarray can have exactly 1 odd number.

example_3.py — All Odd Numbers

$ Input: nums = [1,3,5], k = 3

› Output: 1

💡 Note: Only the entire array [1,3,5] contains exactly 3 odd numbers.

Visualization

Tap to expand

Understanding the Visualization

Binary Transformation

Convert the number array to binary: odd numbers become 1, even numbers become 0

Prefix Sum Tracking

Maintain running count of 1s encountered so far (prefix sum)

Hash Map Magic

For each position, check if there's a previous position where prefix sum differs by exactly k

Count Valid Pairs

Each valid pair represents the start and end of a nice subarray

Key Takeaway

🎯 Key Insight: By transforming the problem to prefix sums, we reduce the complexity from O(n²) checking all subarrays to O(n) using mathematical properties and hash map lookups.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with O(1) hash map operations

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n different prefix sum values

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ nums.length
All elements are positive integers

Asked in

f Facebook 85 a Amazon 72 G Google 68 ⊞ Microsoft 45 Apple 38

The optimal solution uses prefix sums with hash map to achieve O(n) time complexity. Key insight: convert the problem to finding subarrays with sum k in a binary array (odd→1, even→0), then use the standard subarray sum equals k technique with hash map to count valid subarrays efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray and count odd numbers
Prefix Sum with HashMap (Optimal)	O(n)	O(n)	Use prefix sums and hash map to count valid subarrays in one pass

Brute Force (Check All Subarrays) — Algorithm Steps

Use outer loop to fix the starting position of subarray
Use inner loop to extend the subarray from start position
For each subarray, count the number of odd elements
If count equals k, increment result counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Begin checking subarrays starting from index 0

Extend subarray

Keep adding elements and counting odd numbers

Check condition

If odd count equals k, increment result

Move to next start

Repeat process from next starting position

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int numSubarraysWithKOdds(int* nums, int numsSize, int k) {
    int count = 0;
    
    // Check all possible subarrays
    for (int i = 0; i < numsSize; i++) {
        int oddCount = 0;
        for (int j = i; j < numsSize; j++) {
            // Count odd numbers in current subarray
            if (nums[j] % 2 == 1) {
                oddCount++;
            }
            
            // If we have exactly k odd numbers, increment count
            if (oddCount == k) {
                count++;
            }
            // If we have more than k odd numbers, break
            else if (oddCount > k) {
                break;
            }
        }
    }
    
    return count;
}

int main() {
    int nums[] = {1, 1, 2, 1, 1};
    int k = 3;
    printf("%d\n", numSubarraysWithKOdds(nums, 5, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops iterate through all possible subarrays

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track counts

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ nums.length
All elements are positive integers

87.5K Views

High Frequency

~18 min Avg. Time

2.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler