Peaks in Array

Peaks in Array - Problem

A peak in an array arr is an element that is greater than its previous and next element in arr.

You are given an integer array nums and a 2D integer array queries. You have to process queries of two types:

queries[i] = [1, li, ri] - determine the count of peak elements in the subarray nums[li..ri]
queries[i] = [2, indexi, vali] - change nums[indexi] to vali

Return an array answer containing the results of the queries of the first type in order.

Note: The first and the last element of an array or a subarray cannot be a peak.

Input & Output

Example 1 — Basic Peak Counting

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

› Output: [1]

💡 Note: After updating nums[3] = 4, array becomes [2,8,6,4,5]. Query [1,0,4] counts peaks in range [0,4]. Only index 1 (value 8) is a peak since 8 > 2 and 8 > 6.

Example 2 — Multiple Queries

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

› Output: [1,1]

💡 Note: First query [1,1,4]: checks indices 2,3 in range [1,4]. Index 2: 2 < 3 (not peak). Index 3: 4 > 2 and 4 > 1 (peak). Count=1. After update nums[2]=5: [1,3,5,4,1]. Second query [1,0,3]: checks indices 1,2 in range [0,3]. Index 1: 3 < 5 (not peak). Index 2: 5 > 3 and 5 > 4 (peak). Count=1.

Example 3 — Edge Case No Peaks

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

› Output: [0]

💡 Note: Range [0,2] has no valid peak positions since first and last elements cannot be peaks. Only index 1 could be a peak, but 2 < 3, so no peaks found.

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

Asked in

G Google 25 f Facebook 18 a Amazon 15 M Microsoft 12

The key insight is to precompute peak information and use efficient data structures for range operations. The segment tree approach provides O(log n) queries and updates by maintaining peak counts in tree nodes. Best approach is segment tree with lazy propagation: Time O(n + q log n), Space O(n).

Common Approaches

✓ Brute Force Range Scanning

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

Process each query independently by scanning through the specified range and counting elements that are greater than both neighbors. For update queries, modify the array and recalculate affected peaks.

Segment Tree with Lazy Propagation

⏱️ Time: O(n + q log n) Space: O(n)

Build a segment tree where each node stores the count of peaks in its range. Use lazy propagation to handle updates efficiently. When updating a value, only recalculate peaks for affected positions.

Brute Force Range Scanning — Algorithm Steps

Step 1: For type 1 queries, iterate through range [l+1, r-1] and count peaks
Step 2: For type 2 queries, update the array value
Step 3: After updates, recalculate peak status for affected positions

Visualization

Tap to expand

Step-by-Step Walkthrough

Query Processing

For each query, scan the specified range

Peak Detection

Check if each element is greater than both neighbors

Count & Update

Count peaks for type 1, update array for type 2

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.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));
    int resultIndex = 0;
    
    for (int i = 0; i < queriesSize; i++) {
        if (queries[i][0] == 1) { // Count peaks in range
            int l = queries[i][1], r = queries[i][2];
            int count = 0;
            for (int j = l + 1; j < r; j++) { // Can't include first and last
                if (isPeak(nums, numsSize, j)) {
                    count++;
                }
            }
            result[resultIndex++] = count;
        } else { // Update value
            int index = queries[i][1], val = queries[i][2];
            nums[index] = val;
        }
    }
    
    *returnSize = resultIndex;
    return result;
}

int main() {
    char line[10000];
    
    // Read nums array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse nums - simple parsing for [1,2,3] format
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    // Read queries array
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Simple parsing for queries
    int queries[100][3];
    int* queryPtrs[100];
    int queriesSize = 0;
    int queriesColSize[100];
    
    char* ptr = line + 1; // Skip first [
    while (*ptr) {
        if (*ptr == '[') {
            ptr++;
            int col = 0;
            while (*ptr != ']') {
                if (*ptr >= '0' && *ptr <= '9' || *ptr == '-') {
                    queries[queriesSize][col++] = atoi(ptr);
                    while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
                } else {
                    ptr++;
                }
            }
            queryPtrs[queriesSize] = queries[queriesSize];
            queriesColSize[queriesSize] = col;
            queriesSize++;
            ptr++;
        } else {
            ptr++;
        }
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, queryPtrs, queriesSize, queriesColSize, &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(q × n)

For each of q queries, we may scan up to n elements in the worst case

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~35 min Avg. Time

450 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 Range Scanning — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler