Zero Array Transformation I - Practice Coding Problems

Zero Array Transformation I - Problem

You're given an integer array nums and a series of range operations defined by a 2D array queries. Each query queries[i] = [li, ri] allows you to select any subset of indices within the range [li, ri] and decrement those values by 1.

Your goal is to determine if it's possible to transform the entire array into a Zero Array (all elements equal to 0) by strategically applying all the given queries.

Key Points:

You must process all queries sequentially
For each query, you can choose which indices in the range to decrement
Each selected index gets decremented by exactly 1
Return true if transformation to all zeros is possible, false otherwise

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, 0, 1], queries = [[0, 2]]

› Output: true

💡 Note: Query [0, 2] can decrement indices 0 and 2, making the array [0, 0, 0]

example_2.py — Insufficient Coverage

$ Input: nums = [4, 3, 2, 1], queries = [[1, 3], [0, 2]]

› Output: false

💡 Note: Position 0 needs 4 decrements but only query [0, 2] covers it, providing maximum 1 decrement

example_3.py — Perfect Match

$ Input: nums = [2, 1, 1], queries = [[0, 1], [1, 2], [0, 2]]

› Output: true

💡 Note: Each position has enough query coverage: pos 0 has 2 queries, pos 1 has 3 queries, pos 2 has 2 queries

Visualization

Tap to expand

Understanding the Visualization

Count Coverage

Calculate how many supply deliveries can serve each department

Compare Demands

Check if available deliveries ≥ department needs

Verify Feasibility

All departments can be satisfied if coverage is sufficient

Key Takeaway

🎯 Key Insight: Rather than trying every possible distribution combination, we can solve this efficiently by counting how many times each position could potentially be decremented and comparing with the required amount.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through array (n) and queries (m) to count overlaps

✓ Linear Growth

Space Complexity

O(n)

Array to store count of possible decrements per position

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ l_i ≤ r_i < nums.length

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal approach uses prefix sum counting to determine if each position has sufficient query coverage. Instead of simulating all possible query applications, we count how many queries can potentially decrement each position and verify this count meets the original values. This achieves O(n + m) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Prefix Sum Approach (Optimal)	O(n + m)	O(n)	Use prefix sums to track maximum possible decrements at each position

Greedy Prefix Sum Approach (Optimal) — Algorithm Steps

Count how many queries can affect each position using range overlap
For each position, check if available decrements >= original value
Use prefix sum technique for efficient range counting
Return true if all positions can be reduced to zero

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Counter

Create array to count decrements per position

Process Queries

For each query range, increment counters

Verify Sufficiency

Check if counters >= original values

Return Result

All positions reducible to zero?

Code -

solution.c — C

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

bool isZeroArray(int* nums, int numsSize, int** queries, int queriesSize, int* queriesColSize) {
    int* decrements = (int*)calloc(numsSize, sizeof(int));
    
    // Count available decrements
    for (int q = 0; q < queriesSize; q++) {
        int l = queries[q][0], r = queries[q][1];
        for (int i = l; i <= (r < numsSize ? r : numsSize - 1); i++) {
            decrements[i]++;
        }
    }
    
    // Check sufficiency
    for (int i = 0; i < numsSize; i++) {
        if (decrements[i] < nums[i]) {
            free(decrements);
            return false;
        }
    }
    
    free(decrements);
    return true;
}

int main() {
    int nums[] = {1, 0, 1};
    int query1[] = {0, 2};
    int* queries[] = {query1};
    int queriesColSize[] = {2};
    
    printf("%s\n", isZeroArray(nums, 3, queries, 1, queriesColSize) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through array (n) and queries (m) to count overlaps

✓ Linear Growth

Space Complexity

O(n)

Array to store count of possible decrements per position

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 10⁵
0 ≤ nums[i] ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i].length == 2
0 ≤ l_i ≤ r_i < nums.length

24.6K 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

Greedy Prefix Sum Approach (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler