Count Number of Nice Subarrays

Count Number of Nice Subarrays - Problem

Array Hash Table Math Sliding Window Prefix Sum Medium

Given an array of integers nums and an integer k, a continuous subarray is called nice if there are exactly k odd numbers in it.

Return the number of nice sub-arrays.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: The only nice subarrays are [1,1,2,1] and [1,2,1,1], each containing exactly 3 odd numbers.

Example 2 — Smaller k

$ 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 — Single Element

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

› Output: 16

💡 Note: Multiple subarrays contain exactly 2 odd numbers, including various combinations around the two odd numbers at positions 3 and 6.

Constraints

1 ≤ nums.length ≤ 5 × 10⁴
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ nums.length

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8

The key insight is to transform the problem by treating odd numbers as 1 and even numbers as 0, then use either prefix sums with hash map or sliding window technique. The sliding window approach using atMost(k) - atMost(k-1) is most intuitive. Time: O(n), Space: O(1) for sliding window or O(n) for prefix sum.

Common Approaches

✓ Brute Force

⏱️ Time: O(n³) Space: O(1)

Generate all possible subarrays by trying every start and end position. For each subarray, count the odd numbers and increment result if count equals k.

Prefix Sum with Hash Map

⏱️ Time: O(n) Space: O(n)

Convert odd numbers to 1 and even numbers to 0, then use prefix sums. For each position, count how many previous prefix sums differ by exactly k.

Sliding Window

⏱️ Time: O(n) Space: O(1)

Create helper function that counts subarrays with at most k odd numbers. Answer is atMost(k) - atMost(k-1).

Brute Force — Algorithm Steps

Iterate through all possible start positions
For each start, try all possible end positions
Count odd numbers in current subarray
If count equals k, increment result

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Try all start-end combinations

Count Odds

Count odd numbers in each subarray

Match Target

Increment count if odd count equals k

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            int oddCount = 0;
            for (int idx = i; idx <= j; idx++) {
                if (nums[idx] % 2 == 1) {
                    oddCount++;
                }
            }
            if (oddCount == k) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: start position, end position, and counting odd numbers

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

32.0K Views

Medium Frequency

~25 min Avg. Time

892 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler