Longest Mountain in Array - Practice Coding Problems

Longest Mountain in Array - Problem

Mountain Array Explorer

Imagine you're a hiker exploring a landscape represented by an array of elevations. Your goal is to find the longest mountain in this terrain!

A mountain array has these characteristics:
• Must have at least 3 elements
• Has a strict upward slope: arr[0] < arr[1] < ... < arr[peak]
• Followed by a strict downward slope: arr[peak] > arr[peak+1] > ... > arr[end]

Given an array of integers representing elevations, return the length of the longest mountain subarray. If no valid mountain exists, return 0.

Example: In array [2,1,4,7,3,2,5], the mountain [1,4,7,3,2] has length 5.

Input & Output

example_1.py — Python

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

› Output: 5

💡 Note: The longest mountain is [1,4,7,3,2] with length 5. It goes up: 1→4→7, then down: 7→3→2.

example_2.py — Python

$ Input: [2,2,2]

› Output: 0

💡 Note: No mountain exists because all elements are equal. A mountain requires strict increase then strict decrease.

example_3.py — Python

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

› Output: 11

💡 Note: The entire array forms one mountain: goes up 0→1→2→3→4→5, then down 5→4→3→2→1→0.

Visualization

Tap to expand

Understanding the Visualization

Scan the trail

Walk through elevation points one by one

Track ascent

Count consecutive upward steps

Track descent

Count consecutive downward steps after ascent

Measure mountain

When descent ends, calculate total mountain length

Key Takeaway

🎯 Key Insight: A mountain is uniquely defined by its upward and downward segment lengths. By tracking these lengths in one pass, we can efficiently find the longest mountain without checking all possible subarrays.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, examining each element once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track upward/downward lengths and maximum

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 10⁴
0 ≤ arr[i] ≤ 10⁴
Mountain must have both upward and downward segments

Asked in

f Facebook 35 a Amazon 28 G Google 22 ⊞ Microsoft 18

The optimal approach uses two pointers technique to track upward and downward lengths in a single pass. Key insight: a mountain consists of consecutive upward moves followed by consecutive downward moves. We maintain up and down counters, updating them as we traverse. When both counters are positive, we have a valid mountain of length up + down + 1.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n)	O(1)	Use two pointers to track upward and downward lengths in one pass
Brute Force (Check All Subarrays)	O(n²)	O(1)	Check every possible subarray to see if it forms a valid mountain

Two Pointers (Optimal) — Algorithm Steps

Initialize upward and downward length counters
For each position, check if we're going up, down, or flat
If going up: increment upward length, reset downward
If going down: increment downward length (if we have upward)
If flat: reset both counters
Update maximum whenever we have both upward and downward lengths

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize counters

Set up = 0, down = 0, maxLength = 0

Process each element

Compare with previous element to determine trend

Update counters

Increment up/down based on trend, reset when needed

Check for mountain

When up > 0 and down > 0, update maximum length

Code -

solution.c — C

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

int longestMountain(int* arr, int arrSize) {
    if (arrSize < 3) return 0;
    
    int maxLength = 0;
    int up = 0, down = 0;
    
    for (int i = 1; i < arrSize; i++) {
        // Reset if we hit a flat section or start a new upward trend
        if ((down > 0 && arr[i-1] < arr[i]) || arr[i-1] == arr[i]) {
            up = down = 0;
        }
        
        // Update up and down lengths
        if (arr[i-1] < arr[i]) {
            up++;
        } else if (arr[i-1] > arr[i]) {
            down++;
        }
        
        // If we have both upward and downward, we have a mountain
        if (up > 0 && down > 0) {
            int length = up + down + 1;
            if (length > maxLength) {
                maxLength = length;
            }
        }
    }
    
    return maxLength;
}

int main() {
    int arr[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // skip [
    while (scanf("%d%c", &arr[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%d\n", longestMountain(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array, examining each element once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track upward/downward lengths and maximum

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 10⁴
0 ≤ arr[i] ≤ 10⁴
Mountain must have both upward and downward segments

42.4K Views

Medium Frequency

~25 min Avg. Time

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

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler