Compute the Sum of Even Numbers After Queries

We have an array A of integers, and an array queries of queries.

For the i-th query val = queries[i][0], index = queries[i][1], we add val to A[index]. Then, the answer to the i-th query is the sum of the even values of A.

(Here, the given index = queries[i][1] is a 0-based index, and each query permanently modifies the array A.)

Return the answer to all queries. Your answer array should have answer[i] as the answer to the i-th query.

Example 1:
Input: A = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]
Output: [8,6,2,4]
Explanation:
At the beginning, the array is [1,2,3,4].
After adding 1 to A[0], the array is [2,2,3,4], and the sum of even values is 2 + 2 + 4 = 8.
After adding -3 to A[1], the array is [2,-1,3,4], and the sum of even values is 2 + 4 = 6.
After adding -4 to A[0], the array is [-2,-1,3,4], and the sum of even values is -2 + 4 = 2.
After adding 2 to A[3], the array is [-2,-1,3,6], and the sum of even values is -2 + 6 = 4.

Note:
1 <= A.length <= 10000
-10000 <= A[i] <= 10000
1 <= queries.length <= 10000
-10000 <= queries[i][0] <= 10000
0 <= queries[i][1] < A.length

The solution is to do a O(N) at the beginning to get the initial sum of the even numbers, which can be checked via a % 2 == 0 or a & 1 == 0 (oddness bit)

Then, at each query, we need to remove the A[index] from the sum if A[index] is even, update A[index], then update the sum if A[index] is even. This process takes O(N) as we keep a updated sum at each iteration without re-looping the entire array to compute the even sum.

JavaScript Sum of Even Numbers after Queries

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

/**
 * @param {number[]} A
 * @param {number[][]} queries
 * @return {number[]}
 */
var sumEvenAfterQueries = function(A, queries) {
    var sum = [];
    var cursum = A.filter(x => x % 2 === 0).reduce( (a, b) => a + b, 0);
    for (var i = 0; i < queries.length; ++ i) {
        var idx = queries[i][1];
        var val = queries[i][0];
        if (A[idx] % 2 === 0) cursum -= A[idx];
        A[idx] += val;
        if (A[idx] % 2 === 0) cursum += A[idx];
        sum.push(cursum);
    }
    return sum;
};

/**
 * @param {number[]} A
 * @param {number[][]} queries
 * @return {number[]}
 */
var sumEvenAfterQueries = function(A, queries) {
    var sum = [];
    var cursum = A.filter(x => x % 2 === 0).reduce( (a, b) => a + b, 0);
    for (var i = 0; i < queries.length; ++ i) {
        var idx = queries[i][1];
        var val = queries[i][0];
        if (A[idx] % 2 === 0) cursum -= A[idx];
        A[idx] += val;
        if (A[idx] % 2 === 0) cursum += A[idx];
        sum.push(cursum);
    }
    return sum;
};

Java solution to compute the even sum after queries

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Solution {
    public int[] sumEvenAfterQueries(int[] A, int[][] queries) {
        int num = queries.length;
        int[] sum = new int[num];
        int cursum = 0;
        for (int a: A) {
            if (a % 2 == 0) {
                cursum += a;
            }
        }
        for (int i = 0; i < num; ++ i) {
            int idx = queries[i][1];
            int val = queries[i][0];
            if (A[idx] % 2 == 0) cursum -= A[idx];
            A[idx] += val;
            if (A[idx] % 2 == 0) cursum += A[idx];
            sum[i] = cursum;
        }
        return sum;
    }
}

class Solution {
    public int[] sumEvenAfterQueries(int[] A, int[][] queries) {
        int num = queries.length;
        int[] sum = new int[num];
        int cursum = 0;
        for (int a: A) {
            if (a % 2 == 0) {
                cursum += a;
            }
        }
        for (int i = 0; i < num; ++ i) {
            int idx = queries[i][1];
            int val = queries[i][0];
            if (A[idx] % 2 == 0) cursum -= A[idx];
            A[idx] += val;
            if (A[idx] % 2 == 0) cursum += A[idx];
            sum[i] = cursum;
        }
        return sum;
    }
}

Both solutions take O(N) to complete and require O(N) space i.e. the return array of sum. Java is a lot faster than JavaScript, as shown on leetcode online judge, 6ms compared to 120ms.

–EOF (The Ultimate Computing & Technology Blog) —