Peak Index in a Mountain Array - Practice Coding Problems

Peak Index in a Mountain Array - Problem

You are given a mountain array - a special type of array where values strictly increase to reach a peak element, then strictly decrease afterward. Think of it like a mountain profile!

A mountain array arr satisfies these conditions:
• arr.length >= 3
• There exists some index i (the peak) where:
- arr[0] < arr[1] < ... < arr[i-1] < arr[i] (strictly increasing)
- arr[i] > arr[i+1] > ... > arr[arr.length-1] (strictly decreasing)

Your mission: Find the index of the peak element in O(log n) time complexity. The peak is guaranteed to exist and is never at the first or last position.

Example: In array [1, 3, 8, 12, 4, 2], the peak is 12 at index 3.

Input & Output

example_1.py — Basic Mountain

$ Input: [0, 1, 0]

› Output: 1

💡 Note: The peak element is 1 at index 1. This is the simplest mountain with 3 elements.

example_2.py — Larger Mountain

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

› Output: 1

💡 Note: The peak element is 2 at index 1. The array increases to 2, then decreases.

example_3.py — Complex Mountain

$ Input: [0, 10, 5, 2]

› Output: 1

💡 Note: The peak element is 10 at index 1. Even with larger values, the peak principle remains the same.

Visualization

Tap to expand

Key Insight: At any point, we can determine which half contains the peakby checking if we're going uphill (peak to the right) or downhill (peak to the left)

Understanding the Visualization

Survey the Range

Start with the entire mountain range in view

Check Middle Point

Fly to the middle and check if you're going uphill or downhill

Eliminate Half

Based on the slope, eliminate half the mountain from search

Repeat Process

Continue narrowing down until you find the peak

Key Takeaway

🎯 Key Insight: Binary search works because a mountain array has a unique property - at any position, we can determine which side the peak is on by comparing adjacent elements, allowing us to eliminate half the search space each time!

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each iteration eliminates half the remaining elements, leading to log n iterations

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for left, right, and mid pointers

✓ Linear Space

Constraints

3 ≤ arr.length ≤ 10⁴
0 ≤ arr[i] ≤ 10⁶
arr is guaranteed to be a mountain array
The peak is never at index 0 or arr.length - 1

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28

The optimal solution uses binary search to achieve O(log n) time complexity. The key insight is that at any position in the mountain, we can determine if the peak is to our left or right by comparing adjacent elements. If arr[mid] < arr[mid+1], we're still ascending so the peak must be to the right. Otherwise, we're descending or at the peak, so we search left. This eliminates half the search space in each iteration.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search (Optimal)	O(log n)	O(1)	Use binary search to find peak in O(log n) time by eliminating half the search space each iteration
Linear Search (Brute Force)	O(n)	O(1)	Scan from left to right until we find where the increase stops

Binary Search (Optimal) — Algorithm Steps

Initialize left = 0, right = arr.length - 1
While left < right, calculate mid = (left + right) / 2
If arr[mid] < arr[mid+1], peak is to the right: left = mid + 1
Otherwise, peak is at mid or to the left: right = mid
When left == right, we've found the peak

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial range

Start with entire array [left=0, right=5]

Check middle

mid=2, arr[2]=8 < arr[3]=12, go right

Narrow range

New range [left=3, right=5], mid=4

Found peak

arr[3]=12 > arr[4]=4, peak found at index 3

Code -

solution.c — C

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

int peakIndexInMountainArray(int* arr, int arrSize) {
    int left = 0, right = arrSize - 1;
    
    while (left < right) {
        int mid = (left + right) / 2;
        
        // If we're still going uphill, peak is to the right
        if (arr[mid] < arr[mid + 1]) {
            left = mid + 1;
        } else {
            // We're going downhill or at peak, so peak is at mid or left
            right = mid;
        }
    }
    
    return left; // left == right at this point
}

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

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Each iteration eliminates half the remaining elements, leading to log n iterations

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for left, right, and mid pointers

✓ Linear Space

Constraints

3 ≤ arr.length ≤ 10⁴
0 ≤ arr[i] ≤ 10⁶
arr is guaranteed to be a mountain array
The peak is never at index 0 or arr.length - 1

89.7K Views

High Frequency

~15 min Avg. Time

2.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

Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler