Find the Peaks - Practice Coding Problems

Find the Peaks - Problem

Array Enumeration Easy

Imagine you're a mountaineer analyzing the elevation profile of a mountain range! You have an array mountain representing the heights at different points along your path. Your mission is to identify all the peaks - those special positions where the elevation is strictly higher than both neighboring points.

What makes a peak? A peak at index i must satisfy: mountain[i-1] < mountain[i] > mountain[i+1]

Important: The first and last elements cannot be peaks (you need neighbors on both sides!)

Goal: Return an array containing the indices of all peaks in any order.

Example: For [1, 4, 3, 8, 5], index 1 (value 4) and index 3 (value 8) are peaks, so return [1, 3].

Input & Output

example_1.py — Basic Mountain Range

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

› Output: [2]

💡 Note: Only index 2 (value 6) is a peak because 4 < 6 > 3. Index 1 has 2 < 4 but 4 < 6, so not a peak.

example_2.py — Multiple Peaks

$ Input: [1, 4, 3, 8, 5]

› Output: [1, 3]

💡 Note: Index 1 (value 4): 1 < 4 > 3 ✓. Index 3 (value 8): 3 < 8 > 5 ✓. Both are peaks!

example_3.py — No Peaks Edge Case

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

› Output: []

💡 Note: This is a strictly increasing array, so no element is greater than both neighbors. No peaks exist.

Visualization

Tap to expand

Understanding the Visualization

Setup the Trail

We have our elevation array representing the mountain trail

Start Walking

Begin from position 1 (second element) since position 0 cannot be a peak

Check Each Position

At each position, look back and forward to see if you're higher than both neighbors

Mark the Peaks

Whenever you find a position higher than both neighbors, mark it as a peak

Complete the Journey

Continue until position n-2 (second-to-last) since the last position cannot be a peak

Key Takeaway

🎯 Key Insight: A single linear pass checking immediate neighbors is sufficient to find all peaks, making this an optimal O(n) solution.

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element exactly once (except first and last)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, result array doesn't count toward space complexity

✓ Linear Space

Constraints

3 ≤ mountain.length ≤ 1000
1 ≤ mountain[i] ≤ 10⁶
Array length is at least 3 (needed for peaks to exist)

Asked in

G Google 45 a Amazon 38 f Meta 25 Apple 22

The optimal solution uses a single pass approach with O(n) time complexity. We iterate through the array from index 1 to n-2, checking if each element is strictly greater than both neighbors. This simple yet efficient method identifies all peaks in one traversal without requiring any additional data structures.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Single Pass)	O(n)	O(1)	Check each element against its neighbors in a straightforward manner

Brute Force (Single Pass) — Algorithm Steps

Start from index 1 (second element) since first element cannot be a peak
For each element, check if it's greater than both left and right neighbors
If condition is satisfied, add the current index to result
Continue until the second-to-last element (last element cannot be a peak)
Return the list of peak indices

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at Index 1

Begin checking from the second element since the first cannot be a peak

Compare with Neighbors

Check if current element is greater than both left and right neighbors

Mark Peak if Found

If condition is satisfied, add index to result array

Continue to Next

Move to next element and repeat until second-to-last element

Code -

solution.c — C

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

int* findPeaks(int* mountain, int mountainSize, int* returnSize) {
    int* peaks = (int*)malloc(mountainSize * sizeof(int));
    *returnSize = 0;
    
    // Check elements from index 1 to mountainSize-2
    for (int i = 1; i < mountainSize - 1; i++) {
        if (mountain[i-1] < mountain[i] && mountain[i] > mountain[i+1]) {
            peaks[(*returnSize)++] = i;
        }
    }
    
    return peaks;
}

int main() {
    // Simple input parsing for demonstration
    int mountain[] = {1, 4, 3, 8, 5};
    int mountainSize = 5;
    int returnSize;
    
    int* result = findPeaks(mountain, mountainSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element exactly once (except first and last)

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables, result array doesn't count toward space complexity

✓ Linear Space

Constraints

3 ≤ mountain.length ≤ 1000
1 ≤ mountain[i] ≤ 10⁶
Array length is at least 3 (needed for peaks to exist)

28.4K Views

Medium Frequency

~8 min Avg. Time

892 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

Brute Force (Single Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler