Peak Index in a Mountain Array - Practice Coding Problems

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

Understanding the Visualization

Input

Mountain array [0,1,0] - increases then decreases

Process

Find the index where the peak occurs

Output

Return index 1 (the peak position)

Key Takeaway

🎯 Key Insight: Use the slope direction to guide binary search towards the peak

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

Approach	Time	Space	Notes
✓ Binary Search	O(log n)	O(1)	Use binary search by comparing middle element with its neighbor
Linear Search	O(n)	O(1)	Check each element to find where it stops increasing

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

⚡ Linearithmic

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