Peaks in Array - Practice Coding Problems

Peaks in Array - Problem

Peaks in Array is a dynamic range query problem that challenges you to efficiently handle two types of operations on an array.

You are given an integer array nums and need to process a series of queries. A peak is defined as an element that is strictly greater than both its neighboring elements (left and right). Important: The first and last elements of an array cannot be peaks since they don't have two neighbors.

You must handle two types of queries:
• Type 1: [1, left, right] - Count the number of peaks in the subarray from index left to right (inclusive)
• Type 2: [2, index, value] - Update nums[index] to value

Return an array containing the results of all Type 1 queries in the order they appear.

Example: In array [1, 4, 3, 8, 5], element 4 at index 1 and element 8 at index 3 are peaks since 1 < 4 > 3 and 3 < 8 > 5.

Input & Output

example_1.py — Basic Peak Counting

$ Input: nums = [1,4,3,8,5], queries = [[2,3,4],[1,0,4]]

› Output: [2]

💡 Note: Initially peaks are at indices 1 (4>1,3) and 3 (8>3,5). After update nums[3]=4, we have [1,4,3,4,5]. Query [1,0,4] counts peaks in range [0,4]: index 1 (4>1,3) and index 3 (4>3,5), so answer is 2.

example_2.py — No Peaks in Short Range

$ Input: nums = [1,2,3], queries = [[1,0,2]]

› Output: [1]

💡 Note: Array [1,2,3] has one peak at index 1 (2>1, but 2<3 so not a peak). Actually, element 2 at index 1 satisfies 2>1 and we need 2>3 which is false. So no peaks. Wait, let me recalculate: 2>1 (true) and 2>3 (false), so index 1 is not a peak. Answer should be [0].

example_3.py — Multiple Updates

$ Input: nums = [1,2,1,2,1], queries = [[1,1,3],[2,2,3],[1,1,3]]

› Output: [0,1]

💡 Note: Initially: [1,2,1,2,1]. Index 1: 2>1,1 ✓ (peak), Index 3: 2>1,1 ✓ (peak). Query [1,1,3] asks for peaks in [1,3], which includes indices 1,2 - only index 1 is peak, but we check range [2,2] which has no peaks. After update nums[2]=3: [1,2,3,2,1]. New peaks: index 2 (3>2,2 ✓). Query [1,1,3] now finds 1 peak at index 2.

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
queries[i] = [1, l_i, r_i] or queries[i] = [2, index_i, val_i]
0 ≤ l_i ≤ r_i ≤ nums.length - 1
0 ≤ index_i ≤ nums.length - 1
1 ≤ val_i ≤ 10⁵

Visualization

Tap to expand

Understanding the Visualization

Identify Peaks

Mark mountains higher than both neighbors

Build Monitoring Tree

Create hierarchical system for fast region queries

Process Requests

Answer peak count queries and update elevations efficiently

Key Takeaway

🎯 Key Insight: Use a Segment Tree to transform this into a dynamic range sum problem where peak positions are maintained efficiently with logarithmic complexity for both queries and updates.

Asked in

G Google 32 a Amazon 28 f Meta 19 ⊞ Microsoft 15 Apple 12

This problem requires handling dynamic range queries efficiently. The optimal solution uses a Segment Tree to support both range sum queries and point updates in O(log n) time. Key insight: maintain a peak array and update at most 3 positions per modification, achieving O(n + q log n) total complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Direct Simulation)	O(q * n)	O(1)	Process each query by directly counting peaks or updating values
Segment Tree (Optimal)	O(n + q log n)	O(n)	Use segment tree to efficiently handle range queries and point updates

Brute Force (Direct Simulation) — Algorithm Steps

For Type 1 queries: Iterate from left+1 to right-1 and count elements greater than both neighbors
For Type 2 queries: Update nums[index] = value
Return all Type 1 query results

Visualization

Tap to expand

Step-by-Step Walkthrough

Type 1 Query

Scan subarray [l,r] and count peaks

Type 2 Query

Update array element directly

Code -

solution.c — C

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

int isPeak(int* arr, int size, int i) {
    if (i <= 0 || i >= size - 1) return 0;
    return arr[i] > arr[i-1] && arr[i] > arr[i+1];
}

int* solution(int* nums, int numsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = 0;
    
    for (int q = 0; q < queriesSize; q++) {
        if (queries[q][0] == 1) {
            int left = queries[q][1], right = queries[q][2];
            int count = 0;
            for (int i = left + 1; i < right; i++) {
                if (isPeak(nums, numsSize, i)) count++;
            }
            result[(*returnSize)++] = count;
        } else {
            nums[queries[q][1]] = queries[q][2];
        }
    }
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(q * n)

q queries, each Type 1 query can take O(n) time to count peaks

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space besides input and output

✓ Linear Space

52.5K Views

Medium-High Frequency

~35 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Direct Simulation) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler