Find the Peaks

Find the Peaks - Problem

Array Enumeration Easy

You are given a 0-indexed array mountain. Your task is to find all the peaks in the mountain array.

Return an array that consists of indices of peaks in the given array in any order.

Notes:

A peak is defined as an element that is strictly greater than its neighboring elements.
The first and last elements of the array are not a peak.

Input & Output

Example 1 — Basic Case

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

› Output: [2]

💡 Note: Element at index 2 (value 6) is greater than both neighbors: 6 > 4 and 6 > 3

Example 2 — Multiple Peaks

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

› Output: [1,3]

💡 Note: Index 1: 4 > 1 and 4 > 3. Index 3: 8 > 3 and 8 > 5

Example 3 — No Peaks

$ Input: mountain = [1,2,3]

› Output: []

💡 Note: Only one interior element at index 1: 2 > 1 but 2 < 3, so not a peak

Constraints

3 ≤ mountain.length ≤ 1000
1 ≤ mountain[i] ≤ 10⁴

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is that only interior elements can be peaks - first and last elements are excluded by definition. Best approach is single pass comparison checking each interior element against its neighbors. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Check Each Element

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

For each element from index 1 to n-2, check if it's strictly greater than both its left and right neighbors. If so, add its index to the result array.

Single Pass Optimization

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

The core algorithm remains the same since we need to check each interior element. We can add minor optimizations like early bounds checking and handling edge cases efficiently.

Brute Force - Check Each Element — Algorithm Steps

Iterate from index 1 to n-2 (skip first and last)
For each element, compare with left and right neighbors
If element > left AND element > right, add index to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Skip Boundaries

First and last elements cannot be peaks

Compare Neighbors

Check if element > left AND element > right

Collect Indices

Add index to result if it's a peak

Code -

solution.c — C

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

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

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse array
    int mountain[1000];
    int size = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            mountain[size++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = solution(mountain, size, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array checking each element once

✓ Linear Growth

Space Complexity

O(1)

Only using variables for iteration, result array doesn't count toward space complexity

✓ Linear Space

25.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Brute Force - Check Each Element — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler