GeeksforGeeks App
Open App
Browser
Continue

# Find the remaining Array element after adding values in given ranges

Given an array A[] containing N elements and an array queries containing Q queries of type [ X, L, R ] where X is the element to be added to all the elements in the range [L, R]. After performing all Q queries keep on removing two array elements and append their sum into the array till the array size becomes 1. The task is to find this remaining array element.

Note: 1-based indexing is considered.

Example:

Input:  A[] = [ 1, 4, 3, 2, 4 ], queries = [ [5, 1, 2 ], [  -5, 1, 3 ] ]
Output: 9
Explanation:
1st query: Adding 5 to the first and second element, A becomes {6, 9, 3, 2, 4}.
2nd query: Adding -5 to first, second and third element, A becomes {1, 4, -2, 2, 4}.
Operation 1: Select A1=1 and A3 = -2, remove them and
add their sum (1-2=-1) to the array, A becomes {4, 2, 4, -1}.
Operation 2: Select A2=2 and A3 = -1, remove them and
add their sum (2-1=1) to the array, A becomes {4, 4, 1}.
Operation 3: Select A1=4 and A3=1, remove them and
add their sum (4+1=5) to the array, A becomes {4, 5}.
Operation 4: Select the remaining two elements and
add their sum (4+5 = 9) to the array, A becomes {9}.

Input:  A = [1,  2, 3], queries = [ [-3, 1, 3 ] ]
Output: -3

Naive Approach:

First calculate the array A for all Q queries by traversing them and adding queries[i][0] from queries[i][1]-1 to queries[i][2]-1

Then the selection of the elements has to be random but it is important to note that any pair of elements (Ai and Aj) we remove and add its sum ( Ai + Aj ) as new element, we are confirmed to get the sum of the array A as the final remaining element due to the summation property mentioned below:

Sn (sum) = (A1 + A2) + A3 + A4 + . . . + An
Sn = (S12 + A3) + A4 + . . . + An
Sn = (S123 + A4)+ . . . + An
. . . . .
Sn = S123…n

Follow the below illustration for a better understanding

Illustration:

Consider an example A = [a1, a2, a3] and queries = [[x1, 1, 2], [x2, 1, 3]]

1st query:

Adding x1 to the first and second element,
the array A becomes [ a1 + x1,  a2 + x1, a3] .
new a1 = a1 + x1
new a2 = a2 + x1

2nd query:

Adding x2 to first, second and third element,
the array A becomes [ a1 + x2,  a2 + x2, a3 + x2] .
new a1 = a1 + x2
new a2 = a2 + x2
new a3 = a3 + x2

Operation 1:

Select a1 and a3, remove them and add their sum (a1 + a3) to array,
A becomes [a2, (a1 + a3)].
previous a2 become a1 and the added sum will became a2.

Operation 2:

Select a1 and a2, remove them and add their sum (a1 + a2) to array,
A becomes [a1 + a2 + a3]

Follow the steps mentioned below to implement the idea:

• Traverse for all Q queries (say i).
• Traverse from queries[i][1]-1 to queries[i][2]-1 (say j).
• Add queries[i][0] to all array elements in the range.
• After all the loops are over, Traverse the array A[] to find the sum of it and store it in result.
• Return result as the final answer.

Below is the implementation of the above approach :

## C++14

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Function to find the value of the remaining element``int` `randomize(vector<``int``>& A, ``int``& N,``              ``vector >& queries, ``int``& Q)``{``    ``int` `result = 0;` `    ``// Loop to perform the queries``    ``for` `(``int` `i = 0; i < Q; i++) {``        ``for` `(``int` `j = queries[i][1] - 1;``             ``j < queries[i][2]; j++)``            ``A[j] += queries[i][0];``    ``}` `    ``// Loop to find the sum of the array``    ``for` `(``int` `i = 0; i < N; i++)``        ``result += A[i];` `    ``return` `result;``}` `// Driver code``int` `main()``{``    ``vector<``int``> A = { 1, 4, 3, 2, 4 };``    ``int` `N = A.size();``    ``vector > queries``        ``= { { 5, 1, 2 }, { -5, 1, 3 } };``    ``int` `Q = queries.size();` `    ``// Function call``    ``cout << randomize(A, N, queries, Q);``    ``return` `0;``}`

## Java

 `// Java code to implement the approach``import` `java.io.*;``class` `GFG {` `  ``// Function to find the value of the remaining element``  ``static` `int` `randomize(``int``[] A, ``int` `N, ``int``[][] queries,``                       ``int` `Q)``  ``{``    ``int` `result = ``0``;` `    ``// Loop to perform the queries``    ``for` `(``int` `i = ``0``; i < Q; i++) {``      ``for` `(``int` `j = queries[i][``1``] - ``1``;``           ``j < queries[i][``2``]; j++) {``        ``A[j] += queries[i][``0``];``      ``}``    ``}` `    ``// Loop to find the sum of the array``    ``for` `(``int` `i = ``0``; i < N; i++) {``      ``result += A[i];``    ``}``    ``return` `result;``  ``}` `  ``public` `static` `void` `main(String[] args)``  ``{``    ``int``[] A = { ``1``, ``4``, ``3``, ``2``, ``4` `};``    ``int` `N = A.length;``    ``int``[][] queries = { { ``5``, ``1``, ``2` `}, { -``5``, ``1``, ``3` `} };``    ``int` `Q = queries.length;` `    ``// Function call``    ``System.out.print(randomize(A, N, queries, Q));``  ``}``}` `// This code is contributed by lokeshmvs21.`

## Python3

 `# Python code to implement the approach` `# Function to find the value of the remaining element``def` `randomize( A, N, queries, Q) :``    ` `    ``result ``=` `0`` ` `    ``# Loop to perform the queries``    ``for` `i ``in` `range``(``0``, Q):``        ``for` `j ``in` `range``(queries[i][``1``] ``-` `1``, queries[i][``2``], ``1``):``            ``A[j] ``+``=` `queries[i][``0``]`` ` `    ``# Loop to find the sum of the array``    ``for` `i ``in` `range``(N):``        ``result ``+``=` `A[i]`` ` `    ``return` `result` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``A ``=` `[ ``1``, ``4``, ``3``, ``2``, ``4` `]``    ``N ``=` `len``(A)``    ``queries ``=` `[[ ``5``, ``1``, ``2` `], [ ``-``5``, ``1``, ``3`  `]]``    ``Q ``=` `len``(queries)`` ` `    ``# Function call``    ``print``( randomize(A, N, queries, Q))` `# This code is contributed by code_hunt.`

## C#

 `// C# code to implement the approach` `using` `System;` `class` `GFG {` `  ``// Function to find the value of the remaining element``  ``static` `int` `randomize(``int``[] A, ``int` `N, ``int``[,] queries,``                       ``int` `Q)``  ``{``    ``int` `result = 0;` `    ``// Loop to perform the queries``    ``for` `(``int` `i = 0; i < Q; i++) {``      ``for` `(``int` `j = queries[i,1] - 1;``           ``j < queries[i,2]; j++) {``        ``A[j] += queries[i,0];``      ``}``    ``}` `    ``// Loop to find the sum of the array``    ``for` `(``int` `i = 0; i < N; i++) {``      ``result += A[i];``    ``}``    ``return` `result;``  ``}` `  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int``[] A = { 1, 4, 3, 2, 4 };``    ``int` `N = A.Length;``    ``int``[,] queries = { { 5, 1, 2 }, { -5, 1, 3 } };``    ``int` `Q = queries.GetLength(0);` `    ``// Function call``    ``Console.WriteLine(randomize(A, N, queries, Q));``  ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``

Output

`9`

Time Complexity: O(Q*M + N) where M is the maximum range among the queries
Auxiliary Space: O(1)

Efficient Approach: The problem can also be solved efficiently by reducing the time requirement of query updates. The idea is as follows.

If we see clearly, we can find our answer by doing things backward.

• First we add all the elements present in A into a element ans and then,
• Add the elements present in queries to the range which is provided with it, i.e., simply add the queries [i]*((L-R)+1) to ans rather than applying it to the given range [L, R].

• Traverse A and add all the elements present in it.
• Traverse queries and add queries[i][0] * ((queries[i][1]-queries[i][2])+1) to the sum.
• Return the sum as the required answer.

Below is the implementation of the above approach :

## C++14

 `// C++ code to implement the approach` `#include ``using` `namespace` `std;` `// Function to find the remaining value``int` `solve(vector<``int``>& v,``          ``vector >& queries)``{``    ``int` `ans = 0;` `    ``// Loop to calculate the array sum``    ``for` `(``int` `i = 0; i < v.size(); i++) {``        ``ans += v[i];``    ``}` `    ``// Loop to process the queries``    ``for` `(``int` `i = 0; i < queries.size(); i++) {``        ``int` `temp = ``abs``(queries[i][1] - queries[i][2]) + 1;``        ``ans += queries[i][0] * temp;``    ``}``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``vector<``int``> A = { 1, 4, 3, 2, 4 };``    ``int` `N = A.size();``    ``vector > queries``        ``= { { 5, 1, 2 }, { -5, 1, 3 } };` `    ``// Function call``    ``cout << solve(A, queries);``    ``return` `0;``}`

## Java

 `// Java code to implement the approach``import` `java.io.*;` `class` `GFG {``    ``// Function to find the remaining value``    ``public` `static` `int` `solve(``int` `v[], ``int` `queries[][])``    ``{``        ``int` `ans = ``0``;` `        ``// Loop to calculate the array sum``        ``for` `(``int` `i = ``0``; i < v.length; i++) {``            ``ans += v[i];``        ``}` `        ``// Loop to process the queries``        ``for` `(``int` `i = ``0``; i < queries.length; i++) {``            ``int` `temp``                ``= Math.abs(queries[i][``1``] - queries[i][``2``])``                  ``+ ``1``;``            ``ans += queries[i][``0``] * temp;``        ``}``        ``return` `ans;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `A[] = { ``1``, ``4``, ``3``, ``2``, ``4` `};``        ``int` `N = A.length;``        ``int` `queries[][] = { { ``5``, ``1``, ``2` `}, { -``5``, ``1``, ``3` `} };` `        ``// Function call``        ``System.out.print(solve(A, queries));``    ``}``}` `// This code is contributed by Rohit Pradhan`

## Python3

 `# python code to implement the approach``# Function to find the remaining value``def` `solve(v, queries):``  ``ans ``=` `0``  ` `  ``# Loop to calculate the array sum``  ``for` `i ``in` `range``(``len``(v)):``    ``ans ``=` `ans ``+` `v[i]``    ` `  ``# Loop to process the queries``  ``for` `i ``in` `range``(``len``(queries)):``    ``temp ``=` `abs``(queries[i][``1``] ``-` `queries[i][``2``]) ``+` `1``    ``ans ``=` `ans ``+` `(queries[i][``0``] ``*` `temp)``  ``return` `ans` `# Driver code``A ``=` `[``1``, ``4``, ``3``, ``2``, ``4``]``N ``=` `len``(A)``queries ``=` `[[``5``, ``1``, ``2` `],[``-``5``, ``1``, ``3` `]]` `# Function call``print` `(solve(A,queries))` `# This code is contributed by Atul_kumar_Shrivastava`

## C#

 `// C# code to implement the approach``using` `System;` `public` `class` `GFG {` `  ``// Function to find the remaining value``  ``public` `static` `int` `solve(``int` `[]v, ``int` `[,]queries)``  ``{``    ``int` `ans = 0;` `    ``// Loop to calculate the array sum``    ``for` `(``int` `i = 0; i < v.Length; i++) {``      ``ans += v[i];``    ``}` `    ``// Loop to process the queries``    ``for` `(``int` `i = 0; i < queries.GetLength(0); i++) {``      ``int` `temp``        ``= Math.Abs(queries[i,1] - queries[i,2])``        ``+ 1;``      ``ans += queries[i,0] * temp;``    ``}``    ``return` `ans;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int` `[]A = { 1, 4, 3, 2, 4 };``    ``int` `N = A.Length;``    ``int` `[,]queries = { { 5, 1, 2 }, { -5, 1, 3 } };` `    ``// Function call``    ``Console.WriteLine(solve(A, queries));``  ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``

Output

`9`

Time Complexity: O(N + Q)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up