Make a Positive Array - Practice Coding Problems

Make a Positive Array - Problem

You are given an integer array nums. Your goal is to transform this array into a positive array using the minimum number of operations possible.

An array is considered positive if every subarray with more than two elements has a positive sum. In other words, for any subarray nums[i...j] where j - i + 1 > 2, the sum of all elements in that subarray must be greater than 0.

Operation: You can replace any element in the array with any integer between -10¹⁸ and 10¹⁸.

Your task: Find the minimum number of operations needed to make the array positive.

Example: For array [1, -5, 2, -3], the subarray [1, -5, 2] has sum -2 (negative), and [-5, 2, -3] has sum -6 (negative). We need to fix these violations with minimum operations.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1, -5, 2, -3]

› Output: 2

💡 Note: The subarray [1, -5, 2] has sum -2 (negative), and [-5, 2, -3] has sum -6 (negative), and [1, -5, 2, -3] has sum -5 (negative). We need to modify at least 2 elements to make all subarrays of length 3+ positive.

example_2.py — Already Positive

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

› Output: 0

💡 Note: All subarrays with length 3+ already have positive sums: [5,3,1]=9, [3,1,2]=6, [5,3,1,2]=11. No operations needed.

example_3.py — Small Array

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

› Output: 0

💡 Note: Array has only 2 elements, so no subarrays with more than 2 elements exist. The array is already positive by definition.

Constraints

1 ≤ nums.length ≤ 1000
-10¹⁸ ≤ nums[i] ≤ 10¹⁸
At least 60% of subarrays must have length > 2
Replacement values must be between -10¹⁸ and 10¹⁸

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

We have tanks with different water levels, some negative (below sea level)

Check Sequences

We check every sequence of 3+ tanks to see if total water is positive

Strategic Adjustments

When we find negative totals, we add water to the rightmost tank to fix multiple sequences at once

Optimal Result

Continue until all sequences have positive totals with minimum adjustments

Key Takeaway

🎯 Key Insight: By adjusting the rightmost element in each violating subarray, we can fix multiple overlapping subarrays simultaneously, leading to the minimum number of operations.

Asked in

G Google 42 a Amazon 38 f Meta 29 ⊞ Microsoft 25

The optimal approach uses prefix sums combined with a greedy strategy. We scan through all possible subarrays of length 3+, and when we find one with non-positive sum, we make the minimum adjustment to the rightmost element to fix it and potentially other overlapping subarrays. This minimizes the total number of operations needed.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every subarray of length 3+, identify violations, and fix them one by one
Greedy with Prefix Sum (Optimal)	O(n²)	O(n)	Use prefix sums and greedy strategy to minimize operations

Brute Force (Check All Subarrays) — Algorithm Steps

Generate all subarrays of length 3 or more
Calculate the sum of each subarray
For each negative sum, identify the most negative element
Replace it with a value that makes the sum positive
Repeat until no violations remain

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Subarray [0,2]

Calculate sum of first 3 elements

Check Subarray [0,3]

Calculate sum of first 4 elements

Fix Violations

Replace negative elements to make sums positive

Code -

solution.c — C

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

int solution(int* nums, int numsSize) {
    int operations = 0;
    long long* arr = malloc(numsSize * sizeof(long long));
    
    for (int i = 0; i < numsSize; i++) {
        arr[i] = nums[i];
    }
    
    int changed = 1;
    while (changed) {
        changed = 0;
        for (int i = 0; i < numsSize; i++) {
            for (int j = i + 2; j < numsSize; j++) {
                long long subarraySum = 0;
                for (int k = i; k <= j; k++) {
                    subarraySum += arr[k];
                }
                
                if (subarraySum <= 0) {
                    long long minVal = LLONG_MAX;
                    int minIdx = i;
                    for (int k = i; k <= j; k++) {
                        if (arr[k] < minVal) {
                            minVal = arr[k];
                            minIdx = k;
                        }
                    }
                    
                    long long needed = llabs(subarraySum) + 1;
                    if (needed > arr[minIdx]) {
                        arr[minIdx] = needed;
                    }
                    operations++;
                    changed = 1;
                    break;
                }
            }
            if (changed) break;
        }
    }
    
    free(arr);
    return operations;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

We check O(n²) subarrays and each sum calculation takes O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

28.4K Views

Medium Frequency

~25 min Avg. Time

847 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 (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler