Find the remaining Array element after adding values in given ranges
Last Updated :
14 Nov, 2022
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 <bits/stdc++.h>
using namespace std;
// Function to find the value of the remaining element
int randomize(vector<int>& A, int& N,
vector<vector<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;
}
// Driver code
int main()
{
vector<int> A = { 1, 4, 3, 2, 4 };
int N = A.size();
vector<vector<int> > queries
= { { 5, 1, 2 }, { -5, 1, 3 } };
int Q = queries.size();
// Function call
cout << randomize(A, N, queries, Q);
return 0;
}
// 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.
# 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# 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
<script>
// Javascriptcode to implement the approach
// Function to find the value of the remaining element
function randomize( A, N,
queries, Q)
{
let result = 0;
// Loop to perform the queries
for (let i = 0; i < Q; i++) {
for (let j = queries[i][1] - 1;
j < queries[i][2]; j++)
A[j] += queries[i][0];
}
// Loop to find the sum of the array
for (let i = 0; i < N; i++)
result += A[i];
return result;
}
// Driver code
let A = [ 1, 4, 3, 2, 4 ];
let N = A.length;
let queries
= [ [ 5, 1, 2 ], [ -5, 1, 3 ] ];
let Q = queries.length;
// Function call
document.write(randomize(A, N, queries, Q));
// This code is contributed by satwik4409.
</script>
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].
Follow the steps given below:
- 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 <bits/stdc++.h>
using namespace std;
// Function to find the remaining value
int solve(vector<int>& v,
vector<vector<int> >& 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<vector<int> > queries
= { { 5, 1, 2 }, { -5, 1, 3 } };
// Function call
cout << solve(A, queries);
return 0;
}
// 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
# 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# 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
<script>
// JavaScript code for the above approach
// Function to find the remaining value
function solve(v, queries)
{
let ans = 0;
// Loop to calculate the array sum
for (let i = 0; i < v.length; i++) {
ans += v[i];
}
// Loop to process the queries
for (let i = 0; i < queries.length; i++) {
let temp
= Math.abs(queries[i][1] - queries[i][2])
+ 1;
ans += queries[i][0] * temp;
}
return ans;
}
// Driver Code
let A = [ 1, 4, 3, 2, 4 ];
let N = A.length;
let queries = [[ 5, 1, 2 ], [ -5, 1, 3 ]];
// Function call
document.write(solve(A, queries));
</script>
Time Complexity: O(N + Q)
Auxiliary Space: O(1)
Similar Reads
Find last remaining element after reducing the Array
Given an array arr[] of size N and an integer K. The task is to find the last remaining element in the array after reducing the array. The rules for reducing the array are: The first and last element say X and Y are chosen and removed from the array arr[].The values X and Y are added. Z = X + Y.Inse
10 min read
Maximize Array sum by adding multiple of another Array element in given ranges
Given two arrays X[] and Y[] of length N along with Q queries each of type [L, R] that denotes the subarray of X[] from L to R. The task is to find the maximum sum that can be obtained by applying the following operation for each query: Choose an element from Y[]. Add multiples with alternate +ve an
15+ min read
Find the missing integer in an array if mean is given
Given an array of size N-1 and the mean of N elements (one element is not given). We need to find the missing value X in the array. Examples: Input : a[] = {2, 4, 20}, Mean = 9Output : Missing Element = 10 Explanation : Mean of (2, 4, 20, 10) is (2 + 4 + 20 + 10)/4 = 9 Let x be the missing element M
4 min read
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 have to be added to all the elements
13 min read
Minimum possible sum of array elements after performing the given operation
Given an array arr[] of size N and a number X. If any sub array of the array(possibly empty) arr[i], arr[i+1], ... can be replaced with arr[i]/x, arr[i+1]/x, .... The task is to find the minimum possible sum of the array which can be obtained. Note: The given operation can only be performed once.Exa
9 min read
Queries for count of array elements with values in given range with updates
Given an array arr[] of size N and a matrix Q consisting of queries of the following two types:Â 1 L R : Print the number of elements lying in the range [L, R].2 i x : Set arr[i] = x Examples:Â Input: arr[] = {1, 2, 2, 3, 4, 4, 5, 6}, Q = {{1, {3, 5}}, {1, {2, 4}}, {1, {1, 2}}, {2, {1, 7}}, {1, {1,
15+ min read
Sum of elements of an AP in the given range
Given an arithmetic series in arr and Q queries in the form of [L, R], where L is the left boundary of the range and R is the right boundary. The task is to find the sum of the AP elements in the given range.Note: The range is 1-indexed and 1 ? L, R ? N, where N is the size of arr. Examples: Input:
10 min read
Find sum of all unique elements in the array for K queries
Given an arrays arr[] in which initially all elements are 0 and another array Q[][] containing K queries where every query represents a range [L, R], the task is to add 1 to each subarrays where each subarray is defined by the range [L, R], and return sum of all unique elements.Note: One-based index
8 min read
Maximize every array element by repeatedly adding all valid i+a[i]th array element
Given an array of integers, arr[] of size N, the task is to print all possible sum at each valid index, that can be obtained by adding i + a[i]th (1-based indexing) subsequent elements till i ? N. Examples: Input: arr[] = {4, 1, 4}Output: 4 5 4Explanation:For i = 1, arr[1] = 4.For i = 2, arr[2] = ar
5 min read
Find range of values for S in given Array with values satisfying [ arr[i] = floor((i*S)/K) ]
Given an array arr[] of N positive integers and a positive integer K, the task is to find the range [L, R] such that for all the elements in this range, say S each array element arr[i] is floor((i*S)/K). Examples: Input: N = 5, K = 10, arr[] = {2, 4, 6, 9, 11}Output: 23 23Explanation: When S = 23, s
6 min read