Off-by-one on range boundaries
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Move from brute-force thinking to an efficient approach using array strategy.
Given an integer array nums, return the number of subarrays filled with 0.
A subarray is a contiguous non-empty sequence of elements within an array.
Example 1:
Input: nums = [1,3,0,0,2,0,0,4] Output: 6 Explanation: 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:
Input: nums = [0,0,0,2,0,0] Output: 9 Explanation: There are 5 occurrences of [0] as a subarray. There are 3 occurrences of [0,0] as a subarray. There is 1 occurrence of [0,0,0] as a subarray. There is no occurrence of a subarray with a size more than 3 filled with 0. Therefore, we return 9.
Example 3:
Input: nums = [2,10,2019] Output: 0 Explanation: There is no subarray filled with 0. Therefore, we return 0.
Constraints:
1 <= nums.length <= 105-109 <= nums[i] <= 109Problem summary: Given an integer array nums, return the number of subarrays filled with 0. A subarray is a contiguous non-empty sequence of elements within an array.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Array · Math
[1,3,0,0,2,0,0,4]
[0,0,0,2,0,0]
[2,10,2019]
arithmetic-slices)number-of-smooth-descent-periods-of-a-stock)length-of-the-longest-alphabetical-continuous-substring)find-consecutive-integers-from-a-data-stream)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #2348: Number of Zero-Filled Subarrays
class Solution {
public long zeroFilledSubarray(int[] nums) {
long ans = 0;
int cnt = 0;
for (int x : nums) {
if (x == 0) {
ans += ++cnt;
} else {
cnt = 0;
}
}
return ans;
}
}
// Accepted solution for LeetCode #2348: Number of Zero-Filled Subarrays
func zeroFilledSubarray(nums []int) (ans int64) {
cnt := 0
for _, x := range nums {
if x == 0 {
cnt++
ans += int64(cnt)
} else {
cnt = 0
}
}
return
}
# Accepted solution for LeetCode #2348: Number of Zero-Filled Subarrays
class Solution:
def zeroFilledSubarray(self, nums: List[int]) -> int:
ans = cnt = 0
for x in nums:
if x == 0:
cnt += 1
ans += cnt
else:
cnt = 0
return ans
// Accepted solution for LeetCode #2348: Number of Zero-Filled Subarrays
impl Solution {
pub fn zero_filled_subarray(nums: Vec<i32>) -> i64 {
let mut ans: i64 = 0;
let mut cnt: i64 = 0;
for x in nums {
if x == 0 {
cnt += 1;
ans += cnt;
} else {
cnt = 0;
}
}
ans
}
}
// Accepted solution for LeetCode #2348: Number of Zero-Filled Subarrays
function zeroFilledSubarray(nums: number[]): number {
let [ans, cnt] = [0, 0];
for (const x of nums) {
if (!x) {
ans += ++cnt;
} else {
cnt = 0;
}
}
return ans;
}
Use this to step through a reusable interview workflow for this problem.
Two nested loops check every pair or subarray. The outer loop fixes a starting point, the inner loop extends or searches. For n elements this gives up to n²/2 operations. No extra space, but the quadratic time is prohibitive for large inputs.
Most array problems have an O(n²) brute force (nested loops) and an O(n) optimal (single pass with clever state tracking). The key is identifying what information to maintain as you scan: a running max, a prefix sum, a hash map of seen values, or two pointers.
Review these before coding to avoid predictable interview regressions.
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Wrong move: Temporary multiplications exceed integer bounds.
Usually fails on: Large inputs wrap around unexpectedly.
Fix: Use wider types, modular arithmetic, or rearranged operations.