# Solving Leetcode Interviews in Seconds with AI: Sum of Even Numbers After Queries


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "985" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> You are given an integer array nums and an array queries where queries[i] = [vali, indexi]. For each query i, first, apply nums[indexi] = nums[indexi] + vali, then print the sum of the even values of nums. Return an integer array answer where answer[i] is the answer to the ith query.   Example 1:  Input: nums = [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 nums[0], the array is [2,2,3,4], and the sum of even values is 2 + 2 + 4 = 8. After adding -3 to nums[1], the array is [2,-1,3,4], and the sum of even values is 2 + 4 = 6. After adding -4 to nums[0], the array is [-2,-1,3,4], and the sum of even values is -2 + 4 = 2. After adding 2 to nums[3], the array is [-2,-1,3,6], and the sum of even values is -2 + 6 = 4.  Example 2:  Input: nums = [1], queries = [[4,0]] Output: [0]    Constraints:  1 <= nums.length <= 104 -104 <= nums[i] <= 104 1 <= queries.length <= 104 -104 <= vali <= 104 0 <= indexi < nums.length  

	# Explanation
	Here's a breakdown of the solution, followed by the Python code:

*   **High-Level Approach:**
    *   Calculate the initial sum of even numbers in `nums`.
    *   Iterate through each query, updating the `nums` array in place and adjusting the even sum based on whether the modified number was even before and after the update.
    *   Append the updated even sum to the result array after each query.

*   **Complexity:**
    *   Runtime: O(N + Q), where N is the length of `nums` and Q is the length of `queries`. This is because we iterate through `nums` once to calculate the initial even sum and then iterate through `queries` once.
    *   Storage: O(Q), where Q is the length of `queries` because the result array scales linearly with the number of queries.

	
	# Code
	```python
	def sum_even_after_queries(nums, queries):
    """
    Calculates the sum of even values in nums after each query.

    Args:
        nums: An integer array.
        queries: An array of queries where queries[i] = [vali, indexi].

    Returns:
        An integer array where answer[i] is the answer to the ith query.
    """

    even_sum = 0
    for num in nums:
        if num % 2 == 0:
            even_sum += num

    answer = []
    for val, index in queries:
        if nums[index] % 2 == 0:
            even_sum -= nums[index]

        nums[index] += val

        if nums[index] % 2 == 0:
            even_sum += nums[index]

        answer.append(even_sum)

    return answer
	```