Valid Mountain Array - Practice Coding Problems

Valid Mountain Array - Problem

Array Easy

Imagine you're a cartographer tasked with validating topographical data! 🏔️ You need to determine if an array of integers represents a valid mountain array.

A mountain array has these characteristics:

It must have at least 3 elements (you can't have a mountain with just 1-2 points!)
There exists a peak somewhere in the middle (not at the edges)
Elements strictly increase up to the peak: arr[0] < arr[1] < ... < arr[peak]
Elements strictly decrease after the peak: arr[peak] > arr[peak+1] > ... > arr[n-1]

Goal: Return true if the array forms a valid mountain, false otherwise.

Remember: A valid mountain must go UP first, then DOWN. It cannot have plateaus (equal adjacent elements) or multiple peaks!

Input & Output

example_1.py — Valid Mountain

$ Input: [2,1]

› Output: false

💡 Note: This array is too short (length < 3) and only decreases, so it cannot be a valid mountain.

example_2.py — Valid Mountain

$ Input: [3,5,5]

› Output: false

💡 Note: This has a plateau (5,5) which violates the strictly increasing/decreasing requirement.

example_3.py — Valid Mountain

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

› Output: true

💡 Note: This forms a perfect mountain: increases from 0 to 4, then decreases from 4 to 0.

Visualization

Tap to expand

Understanding the Visualization

Start the Journey

Left hiker starts climbing up, right hiker starts going down

Keep Moving

Each hiker continues as long as the path keeps going their direction

Find the Meeting Point

Both hikers stop when they can't continue - do they meet at the same spot?

Validate the Mountain

Valid mountain if they meet in the middle and both actually moved

Key Takeaway

🎯 Key Insight: A valid mountain can be efficiently detected by checking if ascending from left and descending from right meet at the same peak position!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with two pointers meeting in the middle

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables and no additional data structures

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 10⁴
0 ≤ arr[i] ≤ 10⁴
Array must have exactly one peak (not at edges)
No plateaus allowed (strictly increasing/decreasing)

Asked in

f Facebook 25 a Amazon 18 G Google 15 ⊞ Microsoft 12

The optimal solution uses the two pointers technique in O(n) time. Start one pointer from the left walking upward while elements increase, and another from the right walking downward while elements decrease. A valid mountain exists when both pointers meet at the same peak position and both moved significantly from their starting positions.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal Walk)	O(n)	O(1)	Walk up from left and down from right, check if they meet at a valid peak
Brute Force (Check All Peak Positions)	O(n²)	O(1)	Try each position as a potential peak and validate the entire mountain

Two Pointers (Optimal Walk) — Algorithm Steps

Start left pointer at beginning, walk right while strictly increasing
Start right pointer at end, walk left while strictly decreasing
Check if both pointers meet at the same position
Ensure both pointers moved (no plateau at start/end)

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Walking

Left pointer walks up (increasing), right pointer walks down (decreasing)

Continue Until Stop

Each pointer stops when it can't maintain its direction

Check Meeting Point

Valid mountain if pointers meet at same position and both moved

Code -

solution.c — C

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

bool validMountainArray(int* arr, int n) {
    if (n < 3) return false;
    
    int left = 0;
    int right = n - 1;
    
    // Walk up from left while strictly increasing
    while (left < n - 1 && arr[left] < arr[left + 1]) {
        left++;
    }
    
    // Walk down from right while strictly decreasing
    while (right > 0 && arr[right - 1] > arr[right]) {
        right--;
    }
    
    // Valid mountain: pointers meet, both moved, not at edges
    return left == right && left > 0 && right < n - 1;
}

int main() {
    int arr[1000];
    int n = 0;
    char c;
    
    scanf("%c", &c); // Read '['
    while (scanf("%d%c", &arr[n], &c)) {
        n++;
        if (c == ']') break;
    }
    
    printf("%s\n", validMountainArray(arr, n) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array with two pointers meeting in the middle

✓ Linear Growth

Space Complexity

O(1)

Only using two pointer variables and no additional data structures

✓ Linear Space

Constraints

1 ≤ arr.length ≤ 10⁴
0 ≤ arr[i] ≤ 10⁴
Array must have exactly one peak (not at edges)
No plateaus allowed (strictly increasing/decreasing)

26.7K Views

Medium Frequency

~15 min Avg. Time

890 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 Walk) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler