Peak Index in a Mountain Array

Peak Index in a Mountain Array - Problem

You are given an integer mountain array arr of length n where the values increase to a peak element and then decrease.

Return the index of the peak element.

Your task is to solve it in O(log(n)) time complexity.

What is a mountain array?
A mountain array is an array where:

Array length is at least 3
There exists some index i where arr[0] < arr[1] < ... < arr[i-1] < arr[i] > arr[i+1] > ... > arr[n-1]

Input & Output

Example 1 — Basic Mountain

$ Input: arr = [0,1,0]

› Output: 1

💡 Note: The peak element is at index 1 with value 1. Array goes 0→1→0 forming a mountain.

Example 2 — Larger Mountain

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

› Output: 1

💡 Note: The peak element is at index 1 with value 2. Array goes 0→2→1→0.

Example 3 — Multi-Element Mountain

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

› Output: 1

💡 Note: The peak element is at index 1 with value 10. After the peak, values decrease: 10→5→2.

Constraints

3 ≤ arr.length ≤ 10⁵
0 ≤ arr[i] ≤ 10⁶
arr is guaranteed to be a mountain array

Visualization

Tap to expand

Asked in

G Google 35 f Facebook 28 a Amazon 22

The key insight is to use binary search on the mountain array. At any middle point, compare with the next element to determine which side contains the peak. Best approach is binary search with Time: O(log n), Space: O(1).

Common Approaches

✓ Binary Search

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

Since the array is a mountain, we can use binary search. At any middle point, if the element is less than the next element, the peak must be to the right. Otherwise, the peak is at the current position or to the left.

Linear Search

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

Iterate through the array and find the first element that is greater than both its neighbors, or equivalently, find where the increasing sequence ends.

Binary Search — Algorithm Steps

Set left = 0, right = n-1
Find middle element
If arr[mid] < arr[mid+1], peak is on right side
Otherwise, peak is on left side or at mid
Repeat until left meets right

Visualization

Tap to expand

Step-by-Step Walkthrough

Compare

Check if mid < mid+1

Decide

Move left or right based on slope

Converge

Continue until left meets right

Code -

solution.c — C

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

int solution(int* arr, int n) {
    int left = 0, right = n - 1;
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (arr[mid] < arr[mid + 1]) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    
    return left;
}

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(log n)

Binary search divides search space by half each iteration

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for left, right, mid pointers

✓ Linear Space

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

Constraints

Visualization

Related Problems

Common Approaches

Binary Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler