Longest Even Odd Subarray With Threshold - Practice Coding Problems

Longest Even Odd Subarray With Threshold - Problem

Imagine you're analyzing a sequence of numbers to find the perfect alternating pattern! You need to find the longest contiguous subarray that satisfies three strict conditions:

Must start with an even number - This is your entry point
Must alternate between even and odd - Like a perfect zigzag pattern
All numbers must be ≤ threshold - Stay within the limit!

Given an integer array nums and an integer threshold, return the length of the longest such magical subarray.

Example: For nums = [3,2,5,4] and threshold = 5, the subarray [2,5,4] starting at index 1 has length 3 - it starts with even number 2, alternates (2→5→4), and all numbers ≤ 5.

Input & Output

example_1.py — Basic Example

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

› Output: 3

💡 Note: The subarray [2,5,4] starting at index 1 satisfies all conditions: starts with even number 2, alternates (2→5→4), and all elements ≤ 5.

example_2.py — No Valid Subarray

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

› Output: 1

💡 Note: The subarray [2] at index 1 is the only valid one. [1,2] doesn't work because it doesn't start with an even number.

example_3.py — Threshold Violation

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

› Output: 3

💡 Note: The subarray [2,3,4] has length 3. We can't include 5 because it exceeds the threshold of 4.

Constraints

1 ≤ nums.length ≤ 100
1 ≤ nums[i] ≤ 100
1 ≤ threshold ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Start with Left Foot

Every valid sequence must begin with a 'left foot' dancer (even number)

Alternate Perfectly

Dancers must alternate left-right-left-right (even-odd-even-odd) throughout

Height Limit

No dancer can exceed the maximum height (threshold) allowed

Find Longest Sequence

Among all possible valid sequences, find the one with the most dancers

Key Takeaway

🎯 Key Insight: We only need to track the current valid sequence length, not the actual elements. Reset when rules break, extend when they hold!

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal approach uses a single pass through the array, maintaining the current valid sequence length. When conditions are met, we extend the sequence; when violated, we reset appropriately. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible starting position and extend the subarray as long as conditions are met
Single Pass (Optimal)	O(n)	O(1)	Track current valid sequence length and reset when conditions break

Brute Force (Check All Subarrays) — Algorithm Steps

Iterate through each possible starting index
For each start, check if nums[start] is even and ≤ threshold
If valid, extend the subarray while alternating pattern holds and all elements ≤ threshold
Track the maximum length across all valid subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at each index

Try each position as a potential starting point

Check starting conditions

Verify the element is even and ≤ threshold

Extend the subarray

Keep adding elements while alternating pattern and threshold are maintained

Track maximum

Keep record of the longest valid subarray found

Code -

solution.c — C

#include <stdio.h>

int longestAlternatingSubarray(int* nums, int numsSize, int threshold) {
    int maxLength = 0;
    
    for (int start = 0; start < numsSize; start++) {
        // Check if starting element is even and within threshold
        if (nums[start] % 2 == 0 && nums[start] <= threshold) {
            int length = 1;
            
            // Extend the subarray while conditions are met
            for (int end = start + 1; end < numsSize; end++) {
                // Check threshold condition
                if (nums[end] > threshold) {
                    break;
                }
                
                // Check alternating condition
                if (nums[end] % 2 != nums[end - 1] % 2) {
                    length++;
                } else {
                    break;
                }
            }
            
            if (length > maxLength) {
                maxLength = length;
            }
        }
    }
    
    return maxLength;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each starting position (n), we potentially check up to n elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum lengths

✓ Linear Space

26.8K Views

Medium Frequency

~12 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler