Maximum Length of Subarray With Positive Product

Maximum Length of Subarray With Positive Product - Problem

You're given an array of integers nums, and your task is to find the maximum length of a contiguous subarray where the product of all its elements is positive.

A subarray is a consecutive sequence of elements from the original array. For example, in the array [1, -2, 3, 0], some subarrays are [1], [1, -2], [-2, 3], and [1, -2, 3].

Key insight: A product is positive when there's an even number of negative numbers in the subarray. Zero values act as "barriers" that reset our counting since any product containing zero becomes zero.

Goal: Return the length of the longest subarray with a positive product.

Example: For nums = [1, -2, -3, 4], the subarray [1, -2, -3, 4] has product 24 > 0, so the answer is 4.

Input & Output

example_1.py — Basic Case

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

› Output: 4

💡 Note: The entire array has product 1 × (-2) × (-3) × 4 = 24 > 0, so the maximum length is 4

example_2.py — With Zero

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

› Output: 4

💡 Note: Zero splits the array. The subarray [1, -2, -3, 4] has positive product 24, length 4

example_3.py — All Negative

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

› Output: 2

💡 Note: Best subarrays are [-1, -2] and [-2, -3], both have positive product and length 2

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
nums[i] can be positive, negative, or zero

Visualization

Tap to expand

Understanding the Visualization

Start with both runners at position 0

positive_len = 0, negative_len = 0

Positive number: both runners advance

Both lengths increase (if they were already running)

Negative number: runners swap and advance

The magic happens - positive becomes negative and vice versa

Zero: both runners restart

Reset both lengths to 0 - start fresh from here

Key Takeaway

🎯 Key Insight: We don't need to calculate actual products (which can overflow). Instead, we track the lengths of positive and negative product subarrays, swapping them when we see negative numbers!

Asked in

G Google 45 f Facebook 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses dynamic programming to track the lengths of subarrays with positive and negative products in O(n) time. Key insight: when we encounter a negative number, the roles of positive and negative lengths swap, and zeros reset both lengths.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (Optimal)	O(n)	O(1)	Track positive and negative subarray lengths in a single pass
Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible subarray and calculate its product

Dynamic Programming (Optimal) — Algorithm Steps

Initialize positive_len = 0, negative_len = 0, max_len = 0
For each number in the array:
If number > 0: positive_len++, negative_len = (negative_len > 0) ? negative_len + 1 : 0
If number < 0: swap positive_len and negative_len, then increment both if > 0
If number = 0: reset both lengths to 0
Update max_len with current positive_len

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with positive_len = 0, negative_len = 0

Process each element

Update lengths based on current number's sign

Track maximum

Keep track of the maximum positive length seen

Code -

solution.c — C

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

int getMaxLen(int* nums, int numsSize) {
    int positiveLen = 0;
    int negativeLen = 0;
    int maxLen = 0;
    
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        
        if (num > 0) {
            positiveLen++;
            negativeLen = negativeLen > 0 ? negativeLen + 1 : 0;
        } else if (num < 0) {
            int newPositive = negativeLen > 0 ? negativeLen + 1 : 0;
            int newNegative = positiveLen + 1;
            positiveLen = newPositive;
            negativeLen = newNegative;
        } else {
            positiveLen = 0;
            negativeLen = 0;
        }
        
        if (positiveLen > maxLen) {
            maxLen = positiveLen;
        }
    }
    
    return maxLen;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using a constant number of variables regardless of input size

✓ Linear Space

52.3K Views

Medium-High Frequency

~18 min Avg. Time

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

Dynamic Programming (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler