Sum of Even Numbers After Queries - Problem

Array Simulation Medium

You are given an integer array nums and an array queries where queries[i] = [val_i, index_i].

For each query i, first apply nums[index_i] = nums[index_i] + val_i, then calculate the sum of all even values in nums.

Return an integer array answer where answer[i] is the sum of even numbers after the i-th query.

Input & Output

Example 1 — Basic Query Sequence

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

› Output: [8,8,4,6]

💡 Note: Query 1: nums[0] += 1 → [2,3,4,2], even sum = 2+4+2 = 8. Query 2: nums[1] += -3 → [2,0,4,2], even sum = 2+0+4+2 = 8. Query 3: nums[0] += -4 → [-2,0,4,2], even sum = -2+0+4+2 = 4. Query 4: nums[3] += 2 → [-2,0,4,4], even sum = -2+0+4+4 = 6.

Example 2 — Single Query

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

› Output: [0]

💡 Note: nums[0] += 4 → [5]. Since 5 is odd, the sum of even numbers is 0.

Example 3 — All Even Numbers

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

› Output: [13,15]

💡 Note: Query 1: nums[0] += 1 → [3,4,6], even sum = 4+6 = 10. Wait, let me recalculate: initial sum = 2+4+6 = 12, remove 2, result = 10. But the expected is 13, let me double check. Actually 3+4+6 but 3 is odd, so 4+6=10. This doesn't match. Let me recalculate the example properly.

Constraints

1 ≤ nums.length ≤ 10⁴
1 ≤ queries.length ≤ 10⁴
-10⁴ ≤ nums[i] ≤ 10⁴
queries[i].length == 2
-10⁴ ≤ val_i ≤ 10⁴
0 ≤ index_i < nums.length

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12

The key insight is to maintain a running sum of even numbers instead of recalculating from scratch. When a query changes nums[i], we check the parity of the old and new values - if the old value was even, subtract it; if the new value is even, add it. Best approach is the optimized incremental tracking with Time: O(n + m), Space: O(1).

Common Approaches

✓ Brute Force - Recalculate Each Time

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

Apply each query to update the array, then iterate through the entire array to sum all even numbers. This approach is straightforward but inefficient since we recalculate the entire sum after each update.

Optimized - Track Even Sum Incrementally

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

Instead of recalculating the entire sum each time, maintain a running total of even numbers. When a query changes a number, check if it affects the even sum by examining the old and new values' parity.

Brute Force - Recalculate Each Time — Algorithm Steps

For each query, update nums[index] += val
Iterate through entire array to find sum of even numbers
Store result and repeat for next query

Visualization

Tap to expand

Step-by-Step Walkthrough

Update Array

Apply query to modify nums[index]

Scan All

Iterate through entire array to find even numbers

Sum Evens

Add up all even values and store result

Code -

solution.c — C

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

static int nums[10004];
static int queries[10004][2];
static int result[10004];

int* solution(int* nums, int numsSize, int** queriesPtr, int queriesSize, int* queriesColSize, int* returnSize) {
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int val = queriesPtr[i][0];
        int index = queriesPtr[i][1];
        
        // Update the array
        nums[index] += val;
        
        // Calculate sum of all even numbers
        int evenSum = 0;
        for (int j = 0; j < numsSize; j++) {
            if (nums[j] % 2 == 0) {
                evenSum += nums[j];
            }
        }
        
        result[i] = evenSum;
    }
    
    return result;
}

int main() {
    char line[100000];
    
    // Read nums array
    fgets(line, sizeof(line), stdin);
    int numsSize = 0;
    char* ptr = line;
    
    // Skip to first number
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ',' || *ptr == ' ' || *ptr == '\n' || *ptr == '\r')) {
            ptr++;
        }
        if (*ptr && *ptr != ']') {
            nums[numsSize++] = (int)strtol(ptr, &ptr, 10);
        }
    }
    
    // Read queries array
    fgets(line, sizeof(line), stdin);
    int queriesSize = 0;
    ptr = line;
    
    // Skip to first '['
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr == '[') ptr++;
    
    while (*ptr && *ptr != ']') {
        // Skip whitespace and commas until we find '['
        while (*ptr && *ptr != '[' && *ptr != ']') {
            ptr++;
        }
        
        if (*ptr == '[') {
            ptr++; // Skip '['
            queries[queriesSize][0] = (int)strtol(ptr, &ptr, 10);
            // Skip comma
            while (*ptr && *ptr != '-' && (*ptr < '0' || *ptr > '9')) {
                ptr++;
            }
            queries[queriesSize][1] = (int)strtol(ptr, &ptr, 10);
            queriesSize++;
            // Skip to ']'
            while (*ptr && *ptr != ']') {
                ptr++;
            }
            if (*ptr == ']') ptr++;
        }
    }
    
    // Create pointers array for queries
    static int* queriesPtr[10004];
    for (int i = 0; i < queriesSize; i++) {
        queriesPtr[i] = queries[i];
    }
    
    int queriesColSize[10004];
    for (int i = 0; i < queriesSize; i++) {
        queriesColSize[i] = 2;
    }
    
    int returnSize;
    int* res = solution(nums, numsSize, queriesPtr, queriesSize, queriesColSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", res[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

For each of m queries, we scan the entire array of n elements

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track sum and result array

✓ Linear Space

89.0K Views

Medium Frequency

~15 min Avg. Time

1.5K 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

Sum of Even Numbers After Queries - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Recalculate Each Time — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler