# Find the Initial Array from given array after range sum queries

Given an array arr[] which is the resultant array when a number of queries are performed on the original array. The queries are of the form [l, r, x] where l is the starting index in the array, r is the ending index in the array and x is the integer elements that has to be added to all the elements in the index range [l, r]. The task is to find the original array.

Examples:

Input: arr[] = {5, 7, 8}, l[] = {0}, r[] = {1}, x[] = {2}
Output: 3 5 8
If query [0, 1, 2] is performed on the array {3, 5, 8}
The resultant array will be {5, 7, 8}

Input: arr[] = {20, 30, 20, 70, 100},
l[] = {0, 1, 3},
r[] = {2, 4, 4},
x[] = {10, 20, 30}
Output: 10 0 -10 20 50

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: For each range starting from l to r subtract the corresponding x to get the initial array.

Below is the implementation of the approach:

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Utility function to print the contents of an array ` `void` `printArr(``int` `arr[], ``int` `n) ` `{ ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``cout << arr[i] << ``" "``; ` `    ``} ` `} ` ` `  `// Function to find the original array ` `void` `findOrgArr(``int` `arr[], ``int` `l[], ``int` `r[], ``int` `x[], ` `                ``int` `n, ``int` `q) ` `{ ` `    ``for` `(``int` `j = 0; j < q; j++) { ` `        ``for` `(``int` `i = l[j]; i <= r[j]; i++) { ` ` `  `            ``// Decrement elements between ` `            ``// l[j] and r[j] by x[j] ` `            ``arr[i] = arr[i] - x[j]; ` `        ``} ` `    ``} ` ` `  `    ``printArr(arr, n); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Final array ` `    ``int` `arr[] = { 20, 30, 20, 70, 100 }; ` ` `  `    ``// Size of the array ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``// Queries ` `    ``int` `l[] = { 0, 1, 3 }; ` `    ``int` `r[] = { 2, 4, 4 }; ` `    ``int` `x[] = { 10, 20, 30 }; ` ` `  `    ``// Number of queries ` `    ``int` `q = ``sizeof``(l) / ``sizeof``(l); ` ` `  `    ``findOrgArr(arr, l, r, x, n, q); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` ` `  `// Utility function to print the contents of an array ` `static` `void` `printArr(``int` `arr[], ``int` `n) ` `{ ` `    ``for` `(``int` `i = ``0``; i < n; i++) { ` `        ``System.out.print(arr[i]+``" "``); ` `    ``} ` `} ` ` `  `// Function to find the original array ` `static` `void` `findOrgArr(``int` `arr[], ``int` `l[], ``int` `r[], ``int` `x[], ` `                ``int` `n, ``int` `q) ` `{ ` `    ``for` `(``int` `j = ``0``; j < q; j++) { ` `        ``for` `(``int` `i = l[j]; i <= r[j]; i++) { ` ` `  `            ``// Decrement elements between ` `            ``// l[j] and r[j] by x[j] ` `            ``arr[i] = arr[i] - x[j]; ` `        ``} ` `    ``} ` ` `  `    ``printArr(arr, n); ` `} ` ` `  `// Driver code ` `public` `static` `void`  `main(String args[]) ` `{ ` `    ``// Final array ` `    ``int` `arr[] = { ``20``, ``30``, ``20``, ``70``, ``100` `}; ` ` `  `    ``// Size of the array ` `    ``int` `n =  arr.length; ` ` `  `    ``// Queries ` `    ``int` `l[] = { ``0``, ``1``, ``3` `}; ` `    ``int` `r[] = { ``2``, ``4``, ``4` `}; ` `    ``int` `x[] = { ``10``, ``20``, ``30` `}; ` ` `  `    ``// Number of queries ` `    ``int` `q = l.length; ` ` `  `    ``findOrgArr(arr, l, r, x, n, q); ` ` `  `} ` `} ` ` `  `// This code is contributed by ` `// Shashank_Sharma `

## Python3

 `# Python3 implementation of the approach ` `import` `math as mt ` ` `  `# Utility function to print the  ` `# contents of an array ` `def` `printArr(arr, n): ` ` `  `    ``for` `i ``in` `range``(n):  ` `        ``print``(arr[i], end ``=` `" "``) ` ` `  `# Function to find the original array ` `def` `findOrgArr(arr, l, r, x, n, q): ` ` `  `    ``for` `j ``in` `range``(q): ` `        ``for` `i ``in` `range``(l[j], r[j] ``+` `1``): ` `             `  `            ``# Decrement elements between ` `            ``# l[j] and r[j] by x[j] ` `            ``arr[i] ``=` `arr[i] ``-` `x[j] ` `         `  `    ``printArr(arr, n) ` ` `  `# Driver code ` ` `  `# Final array ` `arr ``=` `[``20``, ``30``, ``20``, ``70``, ``100``]  ` ` `  `# Size of the array ` `n ``=` `len``(arr) ` ` `  `# Queries ` `l ``=` `[``0``, ``1``, ``3``]  ` `r ``=` `[ ``2``, ``4``, ``4``]  ` `x ``=` `[ ``10``, ``20``, ``30` `] ` ` `  `# Number of queries ` `q ``=` `len``(l) ` ` `  `findOrgArr(arr, l, r, x, n, q) ` ` `  `# This code is contributed by  ` `# mohit kumar 29 `

## C#

 `// C# implementation of the approach ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Utility function to print the  ` `// contents of an array ` `static` `void` `printArr(``int``[] arr, ``int` `n) ` `{ ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``Console.Write(arr[i] + ``" "``); ` `    ``} ` `} ` ` `  `// Function to find the original array ` `static` `void` `findOrgArr(``int``[] arr, ``int``[] l,  ` `                       ``int``[] r, ``int``[] x,  ` `                       ``int` `n, ``int` `q) ` `{ ` `    ``for` `(``int` `j = 0; j < q; j++)  ` `    ``{ ` `        ``for` `(``int` `i = l[j]; i <= r[j]; i++) ` `        ``{ ` ` `  `            ``// Decrement elements between ` `            ``// l[j] and r[j] by x[j] ` `            ``arr[i] = arr[i] - x[j]; ` `        ``} ` `    ``} ` ` `  `    ``printArr(arr, n); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main() ` `{ ` `    ``// Final array ` `    ``int``[] arr = { 20, 30, 20, 70, 100 }; ` ` `  `    ``// Size of the array ` `    ``int` `n = arr.Length; ` ` `  `    ``// Queries ` `    ``int``[] l = { 0, 1, 3 }; ` `    ``int``[] r = { 2, 4, 4 }; ` `    ``int``[] x = { 10, 20, 30 }; ` ` `  `    ``// Number of queries ` `    ``int` `q = l.Length; ` ` `  `    ``findOrgArr(arr, l, r, x, n, q); ` ` `  `} ` `} ` ` `  `// This code is contributed by ` `// Akanksha Rai `

## PHP

 ` `

Output:

`10 0 -10 20 50 `

Time Complexity: O(n2)

Efficient Approach: Follow the following steps to reach the initial array:

• Take an array b[] of the size of the given array and initialize all of its elements with 0.
• In array b[], for every query update b[l] = b[l] – x and b[r + 1] = b[r + 1] + x if r + 1 < n. This is because x will cancel out the effect of -x when performed the prefix sum.
• Take the prefix sum of array b[], and add it to the given array which will produce the initial array.

## C++

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Utility function to print the contents of an array ` `void` `printArr(``int` `arr[], ``int` `n) ` `{ ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``cout << arr[i] << ``" "``; ` `    ``} ` `} ` ` `  `// Function to find the original array ` `void` `findOrgArr(``int` `arr[], ``int` `l[], ``int` `r[], ``int` `x[], ` `                ``int` `n, ``int` `q) ` `{ ` `    ``int` `b[n] = { 0 }; ` ` `  `    ``for` `(``int` `i = 0; i < q; i++) { ` ` `  `        ``// Decrement the element at l[i]th index by -x ` `        ``b[l[i]] += -x[i]; ` ` `  `        ``// Increment the element at (r[i] + 1)th index ` `        ``// by x if (r[i] + 1) is a valid index ` `        ``if` `(r[i] + 1 < n) ` `            ``b[r[i] + 1] += x[i]; ` `    ``} ` ` `  `    ``for` `(``int` `i = 1; i < n; i++) ` `        ``// Prefix sum of array b ` `        ``b[i] = b[i - 1] + b[i]; ` ` `  `    ``// Update the original array ` `    ``for` `(``int` `i = 0; i < n; i++) ` `        ``arr[i] = arr[i] + b[i]; ` ` `  `    ``printArr(arr, n); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``// Final array ` `    ``int` `arr[] = { 20, 30, 20, 70, 100 }; ` ` `  `    ``// Size of the array ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` ` `  `    ``// Queries ` `    ``int` `l[] = { 0, 1, 3 }; ` `    ``int` `r[] = { 2, 4, 4 }; ` `    ``int` `x[] = { 10, 20, 30 }; ` ` `  `    ``// Number of queries ` `    ``int` `q = ``sizeof``(l) / ``sizeof``(l); ` ` `  `    ``findOrgArr(arr, l, r, x, n, q); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of above approach  ` `class` `GFG{ ` ` `  `    ``// Utility function to print the contents of an array  ` `    ``static` `void` `printArr(``int` `arr[], ``int` `n)  ` `    ``{  ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `        ``{  ` `        ``System.out.print(arr[i] + ``" "``) ;  ` `        ``}  ` `    ``}  ` `     `  `    ``// Function to find the original array  ` `    ``static` `void` `findOrgArr(``int` `arr[], ``int` `l[], ``int` `r[], ``int` `x[],  ` `                    ``int` `n, ``int` `q)  ` `    ``{  ` `        ``int` `b[] = ``new` `int``[n] ; ` `         `  `        ``for` `(``int` `i = ``0``; i < q; i++) ` `            ``b[i] = ``0` `; ` `     `  `        ``for` `(``int` `i = ``0``; i < q; i++) ` `        ``{  ` `     `  `            ``// Decrement the element at l[i]th index by -x  ` `            ``b[l[i]] += -x[i];  ` `     `  `            ``// Increment the element at (r[i] + 1)th index  ` `            ``// by x if (r[i] + 1) is a valid index  ` `            ``if` `(r[i] + ``1` `< n)  ` `                ``b[r[i] + ``1``] += x[i];  ` `        ``}  ` `     `  `        ``for` `(``int` `i = ``1``; i < n; i++)  ` `            ``// Prefix sum of array b  ` `            ``b[i] = b[i - ``1``] + b[i];  ` `     `  `        ``// Update the original array  ` `        ``for` `(``int` `i = ``0``; i < n; i++)  ` `            ``arr[i] = arr[i] + b[i];  ` `     `  `        ``printArr(arr, n);  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `main(String []args) ` `    ``{  ` `        ``// Final array  ` `        ``int` `arr[] = { ``20``, ``30``, ``20``, ``70``, ``100` `};  ` `     `  `        ``// Size of the array  ` `        ``int` `n = arr.length ; ` `     `  `        ``// Queries  ` `        ``int` `l[] = { ``0``, ``1``, ``3` `};  ` `        ``int` `r[] = { ``2``, ``4``, ``4` `};  ` `        ``int` `x[] = { ``10``, ``20``, ``30` `};  ` `     `  `        ``// Number of queries  ` `        ``int` `q = l.length ; ` `     `  `        ``findOrgArr(arr, l, r, x, n, q);  ` `        ``}  ` `} ` ` `  `// This code is contributed by aishwarya.27 `

## Python3

 `# Python3 implementation of the approach ` ` `  `# Utility function to print the contents  ` `# of an array ` `def` `printArr(arr, n): ` ` `  `    ``for` `i ``in` `range``(n): ` `        ``print``(arr[i], end ``=` `" "``) ` ` `  ` `  `# Function to find the original array ` `def` `findOrgArr(arr, l, r, x, n, q): ` ` `  `    ``b ``=` `[``0` `for` `i ``in` `range``(n)] ` ` `  `    ``for` `i ``in` `range``(q): ` ` `  `        ``# Decrement the element at l[i]th  ` `        ``# index by -x ` `        ``b[l[i]] ``+``=` `-``x[i] ` ` `  `        ``# Increment the element at (r[i] + 1)th  ` `        ``# index by x if (r[i] + 1) is a valid index ` `        ``if` `(r[i] ``+` `1` `< n): ` `            ``b[r[i] ``+` `1``] ``+``=` `x[i] ` `     `  `    ``for` `i ``in` `range``(n): ` `         `  `        ``# Prefix sum of array b ` `        ``b[i] ``=` `b[i ``-` `1``] ``+` `b[i] ` ` `  `    ``# Update the original array ` `    ``for` `i ``in` `range``(n): ` `        ``arr[i] ``=` `arr[i] ``+` `b[i] ` ` `  `    ``printArr(arr, n) ` ` `  `# Driver code ` `arr ``=` `[``20``, ``30``, ``20``, ``70``, ``100``] ` ` `  `# Size of the array ` `n ``=` `len``(arr) ` ` `  `# Queries ` `l ``=` `[``0``, ``1``, ``3` `] ` `r ``=` `[``2``, ``4``, ``4` `] ` `x ``=` `[``10``, ``20``, ``30` `] ` ` `  `# Number of queries ` `q ``=` `len``(l) ` ` `  `findOrgArr(arr, l, r, x, n, q) ` ` `  `# This code Is contributed by ` `# Mohit kumar 29 `

## C#

 `// C# implementation of above approach  ` `using` `System; ` ` `  `class` `GFG ` `{ ` ` `  `// Utility function to print the  ` `// contents of an array  ` `static` `void` `printArr(``int``[] arr, ``int` `n)  ` `{  ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{  ` `        ``Console.Write(arr[i] + ``" "``);  ` `    ``}  ` `}  ` ` `  `// Function to find the original array  ` `static` `void` `findOrgArr(``int``[] arr, ``int``[] l,  ` `                       ``int``[] r, ``int``[] x,  ` `                       ``int` `n, ``int` `q)  ` `{  ` `    ``int``[] b = ``new` `int``[n]; ` `     `  `    ``for` `(``int` `i = 0; i < q; i++) ` `        ``b[i] = 0 ; ` ` `  `    ``for` `(``int` `i = 0; i < q; i++) ` `    ``{  ` ` `  `        ``// Decrement the element at l[i]th  ` `        ``// index by -x  ` `        ``b[l[i]] += -x[i];  ` ` `  `        ``// Increment the element at (r[i] + 1)th  ` `        ``// index by x if (r[i] + 1) is a valid index  ` `        ``if` `(r[i] + 1 < n)  ` `            ``b[r[i] + 1] += x[i];  ` `    ``}  ` ` `  `    ``for` `(``int` `i = 1; i < n; i++)  ` `     `  `        ``// Prefix sum of array b  ` `        ``b[i] = b[i - 1] + b[i];  ` ` `  `    ``// Update the original array  ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `        ``arr[i] = arr[i] + b[i];  ` ` `  `    ``printArr(arr, n);  ` `}  ` ` `  `// Driver code  ` `public` `static` `void` `Main() ` `{  ` `    ``// Final array  ` `    ``int``[] arr = { 20, 30, 20, 70, 100 };  ` ` `  `    ``// Size of the array  ` `    ``int` `n = arr.Length; ` ` `  `    ``// Queries  ` `    ``int``[] l = { 0, 1, 3 };  ` `    ``int``[] r = { 2, 4, 4 };  ` `    ``int``[] x = { 10, 20, 30 };  ` ` `  `    ``// Number of queries  ` `    ``int` `q = l.Length; ` ` `  `    ``findOrgArr(arr, l, r, x, n, q);  ` `}  ` `} ` ` `  `// This code is contributed  ` `// by Akanksha Rai `

Output:

`10 0 -10 20 50 `

Time Complexity: O(n)

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.