Longest Turbulent Subarray

Longest Turbulent Subarray - Problem

Given an integer array arr, return the length of a maximum size turbulent subarray of arr.

A subarray is turbulent if the comparison sign flips between each adjacent pair of elements in the subarray.

More formally, a subarray [arr[i], arr[i + 1], ..., arr[j]] of arr is said to be turbulent if and only if:

For i <= k < j: arr[k] > arr[k + 1] when k - i is even, and arr[k] < arr[k + 1] when k - i is odd.
OR, for i <= k < j: arr[k] > arr[k + 1] when k - i is odd, and arr[k] < arr[k + 1] when k - i is even.

Input & Output

Example 1 — Basic Turbulent Array

$ Input: arr = [9,4,2,10,7,8,8,1,9]

› Output: 5

💡 Note: The longest turbulent subarray is [4,2,10,7,8] with pattern: 4 > 2 < 10 > 7 < 8, length = 5

Example 2 — All Equal Elements

$ Input: arr = [4,4,4]

› Output: 1

💡 Note: All elements are equal, so no turbulent subarray exists beyond single elements

Example 3 — Two Elements

$ Input: arr = [100,1]

› Output: 2

💡 Note: A subarray of length 2 with different elements is turbulent: 100 > 1

Constraints

1 ≤ arr.length ≤ 4 × 10⁴
0 ≤ arr[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

A Amazon 35 G Google 28 M Microsoft 22

The key insight is to track turbulent sequences by monitoring when comparison signs alternate. The optimal approach uses dynamic programming with O(n) time and O(1) space, maintaining two states for sequences ending with increasing or decreasing patterns.

Common Approaches

✓ Brute Force

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

For each starting position, expand the subarray as long as it remains turbulent, keeping track of the maximum length found.

Dynamic Programming

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

Use two variables to track the longest turbulent subarray ending at current position with either an increasing or decreasing last comparison.

Sliding Window

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

Maintain a window that grows as long as the alternating pattern continues. When the pattern breaks, start a new window from the current position.

Brute Force — Algorithm Steps

For each starting index i
Expand subarray from i while maintaining turbulent property
Track maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start

Try each position as starting point

Expand

Grow subarray while alternating pattern holds

Track

Keep maximum length found

Code -

solution.c — C

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

int solution(int* arr, int n) {
    if (n <= 1) return n;
    
    int maxLen = 1;
    
    for (int i = 0; i < n; i++) {
        int length = 1;
        for (int j = i + 1; j < n; j++) {
            if (j == i + 1) {
                if (arr[i] != arr[j]) {
                    length = 2;
                } else {
                    break;
                }
            } else {
                int prevIncreasing = arr[j-2] < arr[j-1];
                int currIncreasing = arr[j-1] < arr[j];
                
                if (prevIncreasing != currIncreasing && arr[j-1] != arr[j]) {
                    length++;
                } else {
                    break;
                }
            }
        }
        if (length > maxLen) {
            maxLen = length;
        }
    }
    
    return maxLen;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops: outer loop n times, inner loop up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

28.5K Views

Medium Frequency

~25 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler