Number of Zero-Filled Subarrays - Practice Coding Problems

Number of Zero-Filled Subarrays - Problem

Array Math Medium

Given an integer array nums, your task is to count the total number of subarrays that contain only zeros.

A subarray is a contiguous sequence of elements within an array that maintains the original order. For example, in the array [1, 0, 0, 2], some subarrays include [1], [0, 0], [1, 0, 0, 2], etc.

Goal: Count all possible subarrays where every element is zero.

Example: In [1, 0, 0, 0, 2], the zero-filled subarrays are: [0] (3 times), [0, 0] (2 times), and [0, 0, 0] (1 time), totaling 6 subarrays.

Input & Output

example_1.py — Basic Case

$ Input: [1,3,0,0,2,0,0,4]

› Output: 6

💡 Note: There are 4 occurrences of [0] as a subarray. There are 2 occurrences of [0,0] as a subarray. There is no occurrence of a subarray with a size more than 2 filled with 0. Therefore, we return 6.

example_2.py — All Zeros

$ Input: [0,0,0,2,0,0]

› Output: 9

💡 Note: First segment [0,0,0]: 3*(3+1)/2 = 6 subarrays. Second segment [0,0]: 2*(2+1)/2 = 3 subarrays. Total: 6 + 3 = 9.

example_3.py — No Zeros

$ Input: [2,10,2019]

› Output: 0

💡 Note: There are no subarrays filled with 0, so we return 0.

Visualization

Tap to expand

Understanding the Visualization

Identify Segments

Scan array to find consecutive zero groups

Apply Formula

For each segment of length n, calculate n*(n+1)/2

Sum Results

Add up contributions from all segments

Key Takeaway

🎯 Key Insight: Use n×(n+1)/2 formula to count subarrays in each consecutive zero segment, avoiding the need to enumerate every possible subarray individually.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element visited once

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for segment length tracking

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
The answer will fit in a 64-bit integer

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses mathematical insight to count zero-filled subarrays in O(n) time. Instead of checking every subarray, we identify consecutive zero segments and apply the formula n×(n+1)/2 to count all possible subarrays within each segment. This eliminates redundant calculations and achieves linear time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Check every possible subarray and count those containing only zeros
One-Pass Optimal Solution	O(n)	O(1)	Track consecutive zero segments and use mathematical formula to count subarrays

Brute Force (Nested Loops) — Algorithm Steps

Use outer loop to set starting position of subarray
Use inner loop to extend subarray from start position
For each subarray, check if all elements are zero
If yes, increment counter
Continue until all subarrays are checked

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Fix starting position i

Extend Subarray

Extend ending position j from i to n-1

Check Elements

Verify all elements from i to j are zeros

Count Valid

Increment counter if subarray is all zeros

Code -

solution.c — C

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

long long countZeroFilledSubarrays(int* nums, int n) {
    long long count = 0;
    
    // Generate all possible subarrays
    for (int i = 0; i < n; i++) {
        for (int j = i; j < n; j++) {
            // Check if subarray from i to j contains only zeros
            int allZeros = 1;
            for (int k = i; k <= j; k++) {
                if (nums[k] != 0) {
                    allZeros = 0;
                    break;
                }
            }
            if (allZeros) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    int nums[10000];
    int n = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    printf("%lld\n", countZeroFilledSubarrays(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to generate all subarrays and O(n) to check each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for counters

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
The answer will fit in a 64-bit integer

23.8K Views

Medium Frequency

~15 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler