Sum of Even Numbers After Queries - Practice Coding Problems

Sum of Even Numbers After Queries - Problem

Array Simulation Medium

You're managing a dynamic array of integers where you need to track the sum of even numbers as the array gets modified through a series of queries.

Given an integer array nums and a 2D array queries where queries[i] = [val_i, index_i], you need to:

Update: For each query i, add val_i to nums[index_i]
Calculate: After each update, compute the sum of all even numbers in the modified array
Record: Store this sum as the answer for query i

Goal: Return an array answer where answer[i] represents the sum of even numbers after applying the i-th query.

Example: If nums = [1, 2, 3, 4] and we add 1 to index 0, the array becomes [2, 2, 3, 4]. The sum of even numbers is 2 + 2 + 4 = 8.

Input & Output

example_1.py — Basic Query Processing

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

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

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

example_2.py — Single Element

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

› Output: [0]

💡 Note: Initially even sum = 0 (no even numbers). Query [4,0]: nums[0] = 1+4 = 5, still odd, so even sum remains 0.

example_3.py — All Even Numbers

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

› Output: [13,15,14]

💡 Note: Initially even sum = 2+4+6 = 12. Query [1,0]: nums[0] = 3 (odd), even sum = 4+6 = 10. Wait, this doesn't match - let me recalculate: nums[0] = 2+1 = 3, so even sum = 4+6 = 10. Actually, the expected output should be [13,15,14] meaning: [3+4+6=13, 3+6+6=15, 3+6+5=14].

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Initial Count

Count all premium (even) account balances: $6 total

Transaction Analysis

For each transaction, check if account changes premium status

Smart Update

Update total based on status change, not by recounting all accounts

Key Takeaway

🎯 Key Insight: Instead of recounting all premium accounts after each transaction, track status changes and update the total incrementally - this is the essence of the optimal O(n+m) solution!

Asked in

f Facebook 25 G Google 18 a Amazon 12 ⊞ Microsoft 8

The optimal approach maintains a running sum of even numbers and intelligently updates it based on parity changes. Instead of recalculating the entire sum after each query, we analyze four cases: Even→Even (add the change), Even→Odd (subtract old value), Odd→Even (add new value), and Odd→Odd (no change). This reduces time complexity from O(n×m) to O(n+m).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recalculate Every Time)	O(n * m)	O(1)	After each query, scan the entire array to sum all even numbers
Smart Tracking (Optimal)	O(n + m)	O(1)	Maintain running sum and update based on parity changes

Brute Force (Recalculate Every Time) — Algorithm Steps

For each query [val, index], update nums[index] += val
Iterate through the entire array nums
Sum all even numbers in the array
Add this sum to the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with nums = [1,2,3,4], even sum = 2+4 = 6

Query [1,0]

Update nums[0]: [2,2,3,4], recalculate: 2+2+4 = 8

Query [-3,1]

Update nums[1]: [2,-1,3,4], recalculate: 2+4 = 6

Code -

solution.c — C

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

int* sumEvenAfterQueries(int* nums, int numsSize, int** queries, int queriesSize, int* queriesColSize, int* returnSize) {
    int* result = (int*)malloc(queriesSize * sizeof(int));
    *returnSize = queriesSize;
    
    for (int i = 0; i < queriesSize; i++) {
        int val = queries[i][0];
        int index = queries[i][1];
        
        // Update the array
        nums[index] += val;
        
        // Calculate sum of 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() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

n is array length, m is number of queries. For each query, we scan the entire array

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for calculation, not counting the output array

✓ Linear Space

42.0K Views

Medium Frequency

~15 min Avg. Time

1.7K 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 (Recalculate Every Time) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler