Longest Turbulent Subarray - Practice Coding Problems

Longest Turbulent Subarray - Problem

Imagine a turbulent flight where the plane alternates between climbing and descending rapidly. In this problem, we're looking for the longest "turbulent" sequence in an integer array!

Given an integer array arr, return the length of the longest turbulent subarray. A subarray is turbulent if the comparison signs alternate between adjacent elements - like a rollercoaster that goes up, then down, then up again!

What makes a subarray turbulent?

The inequality signs must flip between each pair: arr[i] < arr[i+1] > arr[i+2] < arr[i+3]...
Or the opposite pattern: arr[i] > arr[i+1] < arr[i+2] > arr[i+3]...
Equal adjacent elements break the turbulence!

Example: In [9,4,2,10,7,8,8,1,9], the longest turbulent subarray is [4,2,10,7,8] with length 5, because: 4 > 2 < 10 > 7 < 8 (signs alternate perfectly!)

Input & Output

example_1.py — 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 alternating pattern: 4 > 2 < 10 > 7 < 8. The equal elements at 8,8 break the turbulence.

example_2.py — Single Element

$ Input: arr = [4,8,12,16]

› Output: 2

💡 Note: No turbulence possible since all comparisons are increasing: 4 < 8 < 12 < 16. Maximum turbulent length is 2 (any two adjacent elements).

example_3.py — All Equal Elements

$ Input: arr = [100]

› Output: 1

💡 Note: Single element array has length 1. No comparisons possible, so the turbulent subarray is just the element itself.

Constraints

1 ≤ arr.length ≤ 4 × 10⁴
0 ≤ arr[i] ≤ 10⁹
Adjacent equal elements break turbulence
Minimum turbulent subarray length is 1

Visualization

Tap to expand

Understanding the Visualization

Set up trackers

Initialize counters for sequences ending with climbs (inc) and drops (dec)

Process each elevation change

For climbs: extend previous drop sequence; For drops: extend previous climb sequence

Handle flat sections

Equal elevations break turbulence - reset both counters to 1

Track the record

Keep updating the maximum turbulent sequence length seen

Key Takeaway

🎯 Key Insight: By maintaining two state variables (inc/dec), we can track all possible turbulent sequences in just one pass, making this an elegant O(n) solution!

Asked in

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

The optimal solution uses dynamic programming to track two states in a single pass: the length of turbulent subarrays ending with an increase and those ending with a decrease. When we see an increasing comparison, we extend the decreasing sequence and reset the increasing one (and vice versa). This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Dynamic Programming (One Pass - Optimal)	O(n)	O(1)	Track increasing and decreasing sequence lengths in a single pass
Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray to see if it's turbulent and track the maximum length

Dynamic Programming (One Pass - Optimal) — Algorithm Steps

Initialize variables to track increasing and decreasing sequence lengths
For each adjacent pair, determine if it's increasing or decreasing
Update the appropriate sequence length and reset the other
Track the maximum length seen so far

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize states

Start with inc=1, dec=1 representing single element sequences

Process comparisons

For each comparison, update the appropriate state and reset the other

Track maximum

Keep track of the maximum length seen across all states

Code -

solution.c — C

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

int maxTurbulenceSize(int* arr, int arrSize) {
    if (arrSize <= 1) return arrSize;
    
    int inc = 1, dec = 1;
    int maxLength = 1;
    
    for (int i = 1; i < arrSize; i++) {
        if (arr[i] > arr[i-1]) {
            inc = dec + 1;
            dec = 1;
        } else if (arr[i] < arr[i-1]) {
            dec = inc + 1;
            inc = 1;
        } else {
            inc = dec = 1;
        }
        
        int currentMax = (inc > dec) ? inc : dec;
        if (currentMax > maxLength) {
            maxLength = currentMax;
        }
    }
    
    return maxLength;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current state

✓ Linear Space

28.5K Views

Medium Frequency

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

Dynamic Programming (One Pass - Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler