# Range Update - Google Top Interview Questions

### Problem Statement :

```You are given a list of integers nums and a two-dimensional list of integers operations.

Each operation is of the following form: [L, R, X], which means that you should increment by X all the elements from indices L to R inclusive in the list (the list is 0-indexed).

Apply all operations and return the final list.

Constraints

n ≤ 10,000 where n is length of nums

o ≤ 10,000 where o is length of operations
Example 1

Input

nums = [7, 3, 1, -10, 3]

operations = [

[0, 0, 3],

[1, 3, 2],

[2, 3, 5]

]

Output

[10, 5, 8, -3, 3]

Explanation

The initial list is [7, 3, 1, -10, 3].

After applying the first operation ([0, 0, 3]) the list becomes [10, 3, 1, -10, 3].

After applying the second operation ([1, 3, 2]) the list becomes [10, 5, 3, -8, 3].

After applying the third operation ([2, 3, 5]) the list becomes [10, 5, 8, -3, 3].```

### Solution :

```                        ```Solution in C++ :

vector<int> solve(vector<int>& nums, vector<vector<int>>& operations) {
int n = nums.size();
int increases[n + 1] = {0};
for (vector<int>& op : operations) {
int L = op;
int R = op;
int X = op;

increases[L] += X;
increases[R + 1] -= X;
}

int s = 0;
vector<int> res;
for (int i = 0; i < n; i++) {
s += increases[i];
res.push_back(s + nums[i]);
}
return res;
}```
```

```                        ```Solution in Java :

import java.util.*;

class Solution {
public int[] solve(int[] nums, int[][] operations) {
if (nums == null || nums.length == 0)
return nums;
int[] temp = new int[nums.length + 1];
for (int[] operation : operations) {
int i = operation, j = operation, cost = operation;
temp[i] += cost;
temp[j + 1] -= cost;
}

for (int i = 1; i < temp.length; i++) temp[i] += temp[i - 1];

for (int i = 0; i < nums.length; i++) nums[i] += temp[i];
return nums;
}
}```
```

```                        ```Solution in Python :

class Solution:
def solve(self, nums, operations):
# [[0, 3], [1, -3], [1, 2], [2, 5], [4, -5], [4, -2]]
# {0: 3, 1: -1, 2: 5, 4: -7}
mp = [0 for _ in range(len(nums) + 1)]
for op in operations:
mp[op] += op
mp[op + 1] -= op
cur = 0
for i in range(len(nums)):
cur += mp[i]
nums[i] += cur
return nums```
```

## View More Similar Problems

Given a pointer to the head of a linked list, insert a new node before the head. The next value in the new node should point to head and the data value should be replaced with a given value. Return a reference to the new head of the list. The head pointer given may be null meaning that the initial list is empty. Function Description: Complete the function insertNodeAtHead in the editor below

## Insert a node at a specific position in a linked list

Given the pointer to the head node of a linked list and an integer to insert at a certain position, create a new node with the given integer as its data attribute, insert this node at the desired position and return the head node. A position of 0 indicates head, a position of 1 indicates one node away from the head and so on. The head pointer given may be null meaning that the initial list is e

## Delete a Node

Delete the node at a given position in a linked list and return a reference to the head node. The head is at position 0. The list may be empty after you delete the node. In that case, return a null value. Example: list=0->1->2->3 position=2 After removing the node at position 2, list'= 0->1->-3. Function Description: Complete the deleteNode function in the editor below. deleteNo

## Print in Reverse

Given a pointer to the head of a singly-linked list, print each data value from the reversed list. If the given list is empty, do not print anything. Example head* refers to the linked list with data values 1->2->3->Null Print the following: 3 2 1 Function Description: Complete the reversePrint function in the editor below. reversePrint has the following parameters: Sing