Longest Alternating Subarray - Practice Coding Problems

Longest Alternating Subarray - Problem

Array Enumeration Easy

You are given a 0-indexed integer array nums. A subarray s of length m is called alternating if:

m is greater than 1.
s[1] = s[0] + 1.
The 0-indexed subarray s looks like [s[0], s[1], s[0], s[1], ..., s[(m-1) % 2]]. In other words, s[1] - s[0] = 1, s[2] - s[1] = -1, s[3] - s[2] = 1, s[4] - s[3] = -1, and so on up to s[m - 1] - s[m - 2] = (-1)^m.

Return the maximum length of all alternating subarrays present in nums or -1 if no such subarray exists.

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

Input & Output

Example 1 — Valid Alternating Pattern

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

› Output: 4

💡 Note: The subarray [4,5,4,5] has length 4 and follows alternating pattern: 4→5 (+1), 5→4 (-1), 4→5 (+1)

Example 2 — No Valid Pattern

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

› Output: -1

💡 Note: No subarray satisfies the alternating pattern requirements (must start with +1 difference)

Example 3 — Multiple Valid Patterns

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

› Output: 5

💡 Note: The entire array [1,2,1,2,1] forms a valid alternating pattern: 1→2 (+1), 2→1 (-1), 1→2 (+1), 2→1 (-1)

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input Array

Array with potential alternating sequences

Find Pattern

Look for +1, -1, +1, -1... differences

Return Length

Maximum length of valid alternating subarray

Key Takeaway

🎯 Key Insight: An alternating pattern must start with difference +1 and then strictly alternate between -1 and +1

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that alternating subarrays must start with consecutive elements differing by +1, then alternate between -1 and +1 differences. The optimal approach scans the array once, finding pattern starts and extending them greedily. Time: O(n), Space: O(1)

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force - Check All Subarrays	O(n³)	O(1)	Check every possible subarray to see if it forms an alternating pattern
Single Pass Optimization	O(n)	O(1)	Scan array once and extend alternating sequences as we find them

Brute Force - Check All Subarrays — Algorithm Steps

Step 1: For each starting index i, try all ending indices j > i
Step 2: Check if subarray[i:j+1] follows alternating pattern
Step 3: Pattern must start with difference +1, then alternate -1, +1, -1, etc.
Step 4: Track the maximum valid length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Try all start-end combinations

Validate Pattern

Check if differences are +1, -1, +1, -1...

Track Maximum

Keep the longest valid length

Code -

solution.c — C

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

int isAlternating(int* nums, int start, int end) {
    if (end - start < 1) return 0;
    
    // Check if second element is first + 1
    if (nums[start + 1] != nums[start] + 1) return 0;
    
    // Check alternating pattern
    for (int i = start + 1; i < end; i++) {
        int expectedDiff = (i - start) % 2 == 1 ? 1 : -1;
        if (nums[i + 1] - nums[i] != expectedDiff) {
            return 0;
        }
    }
    
    return 1;
}

int solution(int* nums, int n) {
    int maxLength = -1;
    
    // Try all possible subarrays
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int length = j - i + 1;
            if (isAlternating(nums, i, j)) {
                if (length > maxLength) {
                    maxLength = length;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int nums[1000];
    int n = 0;
    char* ptr = strchr(line, '[');
    if (ptr) {
        ptr++;
        char* token = strtok(ptr, ",]");
        while (token && n < 1000) {
            nums[n++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    printf("%d\n", solution(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Nested loops for start/end positions O(n²), plus validation of each subarray O(n)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track indices and maximum length

✓ Linear Space

12.5K Views

Medium Frequency

~15 min Avg. Time

287 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