Longest Alternating Subarray - Practice Coding Problems

Longest Alternating Subarray - Problem

Array Enumeration Easy

You are given a 0-indexed integer array nums. Your task is to find the longest alternating subarray within this array.

An alternating subarray is a contiguous sequence that follows a specific zigzag pattern:

It must have length ≥ 2
The second element equals the first element + 1
Elements alternate between two values: [a, a+1, a, a+1, a, a+1, ...]

Example: In array [2, 3, 2, 3, 2, 4], the subarray [2, 3, 2, 3, 2] is alternating with length 5.

Goal: Return the maximum length of any alternating subarray, or -1 if none exists.

Input & Output

example_1.py — Basic Alternating Pattern

$ Input: [2, 3, 2, 3, 2]

› Output: 5

💡 Note: The entire array forms an alternating pattern: starts with 2, next is 3 (2+1), then alternates between 2 and 3. Length is 5.

example_2.py — Multiple Patterns

$ Input: [4, 5, 4, 5, 6, 7, 6]

› Output: 4

💡 Note: Two alternating patterns exist: [4,5,4,5] with length 4, and [6,7,6] with length 3. Maximum is 4.

example_3.py — No Alternating Pattern

$ Input: [1, 3, 2, 4]

› Output: -1

💡 Note: No valid alternating pattern exists. For alternating pattern, second element must be first + 1, but we have 3 ≠ 1+1.

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern Start

Find where OFF switch is followed by ON switch (value + 1)

Extend Pattern

Continue as long as switches alternate: OFF-ON-OFF-ON...

Pattern Breaks

When alternation stops, record length and search for new pattern

Find Maximum

Return the longest alternating sequence found

Key Takeaway

🎯 Key Insight: We can solve this efficiently in one pass by extending alternating patterns when we find them, rather than checking all possible subarrays.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element visited once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum lengths

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
Alternating subarray must have length ≥ 2
Second element must equal first element + 1

Asked in

G Google 45 f Meta 32 a Amazon 28 ⊞ Microsoft 25

The optimal solution uses a one-pass sliding window approach with O(n) time and O(1) space. When we find a valid alternating start (nums[i+1] = nums[i] + 1), we extend the pattern as long as it continues alternating, then reset when it breaks.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray to see if it's alternating
One Pass Sliding Window (Optimal)	O(n)	O(1)	Single pass through array, extending current alternating sequence when possible

Brute Force (Check All Subarrays) — Algorithm Steps

Iterate through each starting position i
For each i, iterate through each ending position j > i
Check if subarray[i:j+1] is alternating
Keep track of maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Choose starting index i

End Position

Choose ending index j > i

Validate Pattern

Check if subarray[i:j+1] is alternating

Update Maximum

Update max length if valid alternating pattern found

Code -

solution.c — C

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

int longestAlternatingSubarray(int* nums, int n) {
    int maxLength = -1;
    
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            // Check if subarray nums[i:j+1] is alternating
            if (j - i + 1 < 2) continue;
            
            // Check if second element is first + 1
            if (nums[i + 1] != nums[i] + 1) continue;
            
            // Check alternating pattern
            int isAlternating = 1;
            int val1 = nums[i], val2 = nums[i + 1];
            
            for (int k = i; k <= j; k++) {
                int expected = (k - i) % 2 == 0 ? val1 : val2;
                if (nums[k] != expected) {
                    isAlternating = 0;
                    break;
                }
            }
            
            if (isAlternating) {
                int currentLength = j - i + 1;
                if (currentLength > maxLength) {
                    maxLength = currentLength;
                }
            }
        }
    }
    
    return maxLength;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) for nested loops to generate subarrays, O(n) to validate each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track current subarray and maximum length

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
Alternating subarray must have length ≥ 2
Second element must equal first element + 1

37.5K Views

Medium Frequency

~18 min Avg. Time

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

Brute Force (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler