Find in Mountain Array - Practice Coding Problems

Find in Mountain Array - Problem

Interactive Mountain Array Search Challenge

Imagine you're exploring a mountain range represented as an array where the elevation strictly increases to a peak, then strictly decreases. This special structure is called a mountain array.

A mountain array arr satisfies:
• arr.length >= 3
• There exists a peak index i where 0 < i < arr.length - 1
• Values strictly increase: arr[0] < arr[1] < ... < arr[i-1] < arr[i]
• Values strictly decrease: arr[i] > arr[i+1] > ... > arr[arr.length-1]

Your Mission: Find the minimum index where mountainArr.get(index) == target. Return -1 if not found.

The Catch: You can't access the array directly! You can only use:
• MountainArray.get(k) - returns element at index k
• MountainArray.length() - returns array length
• Maximum 100 API calls allowed - exceed this and get Wrong Answer!

This constraint forces you to think strategically about minimizing array accesses.

Input & Output

example_1.py — Basic Mountain Search

$ Input: mountain_arr = [1,2,3,4,5,3,1], target = 3

› Output: 2

💡 Note: Target 3 appears at indices 2 and 5. We return 2 because it's the minimum index. The algorithm finds peak at index 4 (value 5), searches ascending side [1,2,3,4,5] and finds 3 at index 2.

example_2.py — Target Not Found

$ Input: mountain_arr = [0,1,2,4,2,1], target = 3

› Output: -1

💡 Note: Target 3 doesn't exist in the mountain array. Peak is at index 3 (value 4). Neither ascending side [0,1,2,4] nor descending side [4,2,1] contains 3.

example_3.py — Target Only on Descending Side

$ Input: mountain_arr = [1,5,2], target = 2

› Output: 2

💡 Note: Peak is at index 1 (value 5). Target 2 is not found in ascending side [1,5], but exists at index 2 in descending side [5,2].

Visualization

Tap to expand

Understanding the Visualization

Find the Peak

Use binary search to locate the highest treasure (peak of the mountain)

Search Ascending Side

Search the left side where treasures increase in value using ascending binary search

Search Descending Side

If not found, search the right side where treasures decrease using descending binary search

Key Takeaway

🎯 Key Insight: By finding the peak first, we can split the mountain into two sorted halves and search each efficiently, using only ~3 log n API calls total.

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Three binary searches, each taking O(log n) time

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

3 <= mountain_arr.length() <= 10⁴
0 <= target <= 10⁹
0 <= mountain_arr.get(index) <= 10⁹
mountain_arr is guaranteed to be a mountain array
Maximum 100 calls to MountainArray.get() allowed

Asked in

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

The optimal solution uses three binary searches: first to find the mountain's peak, then to search the ascending side (left of peak), and finally the descending side if needed. This approach uses only O(log n) API calls, staying well under the 100-call limit while achieving optimal time complexity. The key insight is leveraging the mountain's structure to eliminate half the search space efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ Triple Binary Search (Optimal)	O(log n)	O(1)	Find peak with binary search, then search ascending and descending sides separately
Linear Search (Exceeds API Limit)	O(n)	O(1)	Check every index from left to right until target is found

Triple Binary Search (Optimal) — Algorithm Steps

Use binary search to find the peak index of the mountain array
Perform binary search on the ascending side (indices 0 to peak)
If target found on ascending side, return that index
If not found, perform binary search on descending side (indices peak to n-1)
Return the result from descending side search, or -1 if not found

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Peak

Use binary search to locate the mountain peak

Search Ascending

Binary search the left (ascending) side first

Search Descending

If not found, binary search the right (descending) side

Code -

solution.c — C

int findPeak(struct MountainArray* mountainArr) {
    int left = 0, right = mountainArrLength(mountainArr) - 1;
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (mountainArrGet(mountainArr, mid) < mountainArrGet(mountainArr, mid + 1)) {
            left = mid + 1;
        } else {
            right = mid;
        }
    }
    return left;
}

int binarySearchAscending(int target, struct MountainArray* mountainArr, int left, int right) {
    while (left <= right) {
        int mid = left + (right - left) / 2;
        int val = mountainArrGet(mountainArr, mid);
        if (val == target) {
            return mid;
        } else if (val < target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

int binarySearchDescending(int target, struct MountainArray* mountainArr, int left, int right) {
    while (left <= right) {
        int mid = left + (right - left) / 2;
        int val = mountainArrGet(mountainArr, mid);
        if (val == target) {
            return mid;
        } else if (val > target) {
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    return -1;
}

int findInMountainArray(int target, struct MountainArray* mountainArr) {
    int peak = findPeak(mountainArr);
    
    // Search ascending side first (for minimum index)
    int result = binarySearchAscending(target, mountainArr, 0, peak);
    if (result != -1) {
        return result;
    }
    
    // Search descending side
    return binarySearchDescending(target, mountainArr, peak + 1, mountainArrLength(mountainArr) - 1);
}

Time & Space Complexity

Time Complexity

⏱️

O(log n)

Three binary searches, each taking O(log n) time

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

Constraints

3 <= mountain_arr.length() <= 10⁴
0 <= target <= 10⁹
0 <= mountain_arr.get(index) <= 10⁹
mountain_arr is guaranteed to be a mountain array
Maximum 100 calls to MountainArray.get() allowed

52.3K Views

Medium-High 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

Triple Binary Search (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler