Longest Even Odd Subarray With Threshold

Longest Even Odd Subarray With Threshold - Problem

You are given a 0-indexed integer array nums and an integer threshold.

Find the length of the longest subarray of nums starting at index l and ending at index r (0 <= l <= r < nums.length) that satisfies the following conditions:

nums[l] % 2 == 0 (first element must be even)
For all indices i in the range [l, r - 1], nums[i] % 2 != nums[i + 1] % 2 (alternating even/odd)
For all indices i in the range [l, r], nums[i] <= threshold (all elements within threshold)

Return an integer denoting the length of the longest such subarray.

Note: A subarray is a contiguous non-empty sequence of elements within an array.

Input & Output

Example 1 — Basic Alternating Pattern

$ Input: nums = [3,2,5,4], threshold = 5

› Output: 3

💡 Note: Starting at index 1: [2,5,4] has length 3. Element 2 is even, alternates (2→5→4 = even→odd→even), and all ≤ 5.

Example 2 — Threshold Violation

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

› Output: 1

💡 Note: Starting at index 1: [2] has length 1. Element 2 is even and ≤ 2. Cannot extend to element 1 since we need even start.

Example 3 — No Valid Subarray

$ Input: nums = [2,3,4,5], threshold = 4

› Output: 3

💡 Note: Starting at index 0: [2,3,4] has length 3. Stops at element 5 because 5 > 4 (threshold violation).

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ threshold ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 15 M Microsoft 12 G Google 8

The key insight is to use a sliding window approach that tracks valid subarrays starting with even numbers, maintaining alternating even/odd pattern, and staying within threshold. The optimal sliding window approach processes the array in a single pass with O(n) time complexity. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Check All Subarrays

⏱️ Time: O(n²) Space: O(1)

For each potential starting position (even elements), extend the subarray as long as all three conditions are satisfied. Track the maximum length found.

Sliding Window - Single Pass

⏱️ Time: O(n) Space: O(1)

Maintain a sliding window that expands when conditions are met and resets when any condition breaks. Track the maximum window size encountered.

Brute Force - Check All Subarrays — Algorithm Steps

Step 1: Iterate through each index as potential start
Step 2: For each even element, extend subarray while alternating pattern and threshold conditions hold
Step 3: Track maximum valid subarray length

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Even Starts

Look for even numbers as potential starting points

Extend While Valid

From each start, extend while conditions hold

Track Maximum

Keep track of longest valid subarray found

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int threshold) {
    int maxLength = 0;
    
    for (int i = 0; i < numsSize; i++) {
        // Must start with even number
        if (nums[i] % 2 != 0 || nums[i] > threshold) {
            continue;
        }
        
        int length = 1;
        // Extend the subarray
        for (int j = i + 1; j < numsSize; j++) {
            // Check threshold condition
            if (nums[j] > threshold) {
                break;
            }
            // Check alternating condition
            if (nums[j] % 2 == nums[j-1] % 2) {
                break;
            }
            length++;
        }
        
        if (length > maxLength) {
            maxLength = length;
        }
    }
    
    return maxLength;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int threshold;
    scanf("%d", &threshold);
    
    int result = solution(nums, numsSize, threshold);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Outer loop for starting positions (n) × inner loop for extending subarray (n)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for tracking

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

245 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