# Queries to find the minimum array sum possible by removing elements from either end

• Difficulty Level : Basic
• Last Updated : 10 Nov, 2021

Given an array arr[] consisting of N distinct integers and an array Q[] representing queries, the task for every query Q[i] is to find the minimum sum possible by removing the array elements from either end until Q[i] is obtained.

Examples:

Input: arr[] = {2, 3, 6, 7, 4, 5, 1}, Q[] = {7, 6}
Output: 17 11
Explanation:
Query 1: By popping elements from the end, sum = 1 + 5 + 4 + 7 = 17.
Query 2: Popping elements from the front, sum = 2 + 3 + 6 = 11.

Input: arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, Q[] = {4, 6, 3}
Output: 10 21 6

Naive Approach: The simplest approach to solve the given problem is to traverse the given array from both the ends for each query Q[i] and print the minimum sum obtained from both the traversals till the element with value Q[i] is obtained.

Below is the implementation of the above approach:

## C++14

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the minimum sum for``// each query after removing elements``// from either ends``void` `minSum(``int` `arr[], ``int` `N, ``int` `Q[],``            ``int` `M)``{``    ``// Traverse the query array``    ``for` `(``int` `i = 0; i < M; i++) {``        ``int` `val = Q[i];` `        ``int` `front = 0, rear = 0;` `        ``// Traverse the array from``        ``// the front``        ``for` `(``int` `j = 0; j < N; j++) {``            ``front += arr[j];` `            ``// If element equals val,``            ``// then break out of loop``            ``if` `(arr[j] == val) {``                ``break``;``            ``}``        ``}` `        ``// Traverse the array from rear``        ``for` `(``int` `j = N - 1; j >= 0; j--) {``            ``rear += arr[j];` `            ``// If element equals val, break``            ``if` `(arr[j] == val) {``                ``break``;``            ``}``        ``}` `        ``// Print the minimum of the``        ``// two as the answer``        ``cout << min(front, rear) << ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 2, 3, 6, 7, 4, 5, 1 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `Q[] = { 7, 6 };``    ``int` `M = ``sizeof``(Q) / ``sizeof``(Q);` `    ``// Function Call``    ``minSum(arr, N, Q, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``class` `GFG``{` `// Function to find the minimum sum for``// each query after removing elements``// from either ends``static` `void` `minSum(``int` `arr[], ``int` `N, ``int` `Q[],``            ``int` `M)``{``  ` `    ``// Traverse the query array``    ``for` `(``int` `i = ``0``; i < M; i++)``    ``{``        ``int` `val = Q[i];``        ``int` `front = ``0``, rear = ``0``;` `        ``// Traverse the array from``        ``// the front``        ``for` `(``int` `j = ``0``; j < N; j++)``        ``{``            ``front += arr[j];` `            ``// If element equals val,``            ``// then break out of loop``            ``if` `(arr[j] == val)``            ``{``                ``break``;``            ``}``        ``}` `        ``// Traverse the array from rear``        ``for` `(``int` `j = N - ``1``; j >= ``0``; j--)``        ``{``            ``rear += arr[j];` `            ``// If element equals val, break``            ``if` `(arr[j] == val)``            ``{``                ``break``;``            ``}``        ``}` `        ``// Print the minimum of the``        ``// two as the answer``        ``System.out.print(Math.min(front, rear) + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``2``, ``3``, ``6``, ``7``, ``4``, ``5``, ``1` `};``    ``int` `N = arr.length;``    ``int` `Q[] = { ``7``, ``6` `};``    ``int` `M = Q.length;` `    ``// Function Call``    ``minSum(arr, N, Q, M);``}``}` `// This code is contributed by shikhasingrajput`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum sum for``# each query after removing elements``# from either ends``def` `minSum(arr, N, Q, M):``  ` `    ``# Traverse the query array``    ``for` `i ``in` `range``(M):``        ``val ``=` `Q[i]` `        ``front, rear ``=` `0``, ``0` `        ``# Traverse the array from``        ``# the front``        ``for` `j ``in` `range``(N):``            ``front ``+``=` `arr[j]` `            ``# If element equals val,``            ``# then break out of loop``            ``if` `(arr[j] ``=``=` `val):``                ``break` `        ``# Traverse the array from rear``        ``for` `j ``in` `range``(N ``-` `1``, ``-``1``, ``-``1``):``            ``rear ``+``=` `arr[j]` `            ``# If element equals val, break``            ``if` `(arr[j] ``=``=` `val):``                ``break` `        ``# Print the minimum of the``        ``# two as the answer``        ``print``(``min``(front, rear), end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``2``, ``3``, ``6``, ``7``, ``4``, ``5``, ``1``]``    ``N ``=` `len``(arr)``    ``Q ``=` `[``7``, ``6``]``    ``M ``=` `len``(Q)` `    ``# Function Call``    ``minSum(arr, N, Q, M)` `    ``# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{``    ` `// Function to find the minimum sum for``// each query after removing elements``// from either ends``static` `void` `minSum(``int``[] arr, ``int` `N, ``int``[] Q,``                   ``int` `M)``{``    ` `    ``// Traverse the query array``    ``for``(``int` `i = 0; i < M; i++)``    ``{``        ``int` `val = Q[i];``        ``int` `front = 0, rear = 0;`` ` `        ``// Traverse the array from``        ``// the front``        ``for``(``int` `j = 0; j < N; j++)``        ``{``            ``front += arr[j];`` ` `            ``// If element equals val,``            ``// then break out of loop``            ``if` `(arr[j] == val)``            ``{``                ``break``;``            ``}``        ``}`` ` `        ``// Traverse the array from rear``        ``for``(``int` `j = N - 1; j >= 0; j--)``        ``{``            ``rear += arr[j];`` ` `            ``// If element equals val, break``            ``if` `(arr[j] == val)``            ``{``                ``break``;``            ``}``        ``}`` ` `        ``// Print the minimum of the``        ``// two as the answer``        ``Console.Write(Math.Min(front, rear) + ``" "``);``    ``}``}`` ` `// Driver Code``static` `public` `void` `Main()``{``    ``int``[] arr = { 2, 3, 6, 7, 4, 5, 1 };``    ``int` `N = arr.Length;``    ``int``[] Q = { 7, 6 };``    ``int` `M = Q.Length;`` ` `    ``// Function Call``    ``minSum(arr, N, Q, M);``}``}` `// This code is contributed by rag2127`

## Javascript

 ``

Output:

`17 11`

Time Complexity: O(N*M)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, the idea is to use the Prefix Sum technique to solve this problem. Follow the steps below to solve the problem:

• Create two auxiliary Maps, say M1 and M2.
• Traverse the array from the front and insert the current sum calculated till each index in the Map M1 along with the element.
• Similarly, traverse the array from the back and insert the current sum calculated till each index in the map M2 along with the element.
• Traverse the array Q[] and for each element Q[i], print minimum of M1[Q[i]] and M2[Q[i]] as the minimum possible sum.

Below is the implementation of the above approach:

## C++14

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to find the minimum sum``// for each query after removing``// element from either ends till each``// value Q[i]``void` `minOperations(``int` `arr[], ``int` `N,``                   ``int` `Q[], ``int` `M)``{``    ``// Stores the prefix sum from``    ``// both the ends of the array``    ``map<``int``, ``int``> m1, m2;` `    ``int` `front = 0, rear = 0;` `    ``// Traverse the array from front``    ``for` `(``int` `i = 0; i < N; i++) {``        ``front += arr[i];` `        ``// Insert it into the map m1``        ``m1.insert({ arr[i], front });``    ``}` `    ``// Traverse the array in reverse``    ``for` `(``int` `i = N - 1; i >= 0; i--) {``        ``rear += arr[i];` `        ``// Insert it into the map m2``        ``m2.insert({ arr[i], rear });``    ``}` `    ``// Traverse the query array``    ``for` `(``int` `i = 0; i < M; i++) {` `        ``// Print the minimum of the``        ``// two values as the answer``        ``cout << min(m1[Q[i]], m2[Q[i]])``             ``<< ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 2, 3, 6, 7, 4, 5, 1 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);``    ``int` `Q[] = { 7, 6 };``    ``int` `M = ``sizeof``(Q) / ``sizeof``(Q);` `    ``// Function Call``    ``minOperations(arr, N, Q, M);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{``    ` `// Function to find the minimum sum``// for each query after removing``// element from either ends till each``// value Q[i]``static` `void` `minOperations(``int``[] arr, ``int` `N,``                          ``int``[] Q, ``int` `M)``{``    ` `    ``// Stores the prefix sum from``    ``// both the ends of the array``    ``Map m1 = ``new` `HashMap();``    ``Map m2 = ``new` `HashMap();` `    ``int` `front = ``0``, rear = ``0``;` `    ``// Traverse the array from front``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ``front += arr[i];` `        ``// Insert it into the map m1``        ``m1.put(arr[i], front);``    ``}` `    ``// Traverse the array in reverse``    ``for``(``int` `i = N - ``1``; i >= ``0``; i--)``    ``{``        ``rear += arr[i];` `        ``// Insert it into the map m2``        ``m2.put(arr[i], rear);``    ``}` `    ``// Traverse the query array``    ``for``(``int` `i = ``0``; i < M; i++)``    ``{``        ` `        ``// Print the minimum of the``        ``// two values as the answer``        ``System.out.print(Math.min(m1.get(Q[i]),``                                  ``m2.get(Q[i])) + ``" "``);``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int``[] arr = { ``2``, ``3``, ``6``, ``7``, ``4``, ``5``, ``1` `};``    ``int` `N = arr.length;``    ``int``[] Q = { ``7``, ``6` `};``    ``int` `M = Q.length;``    ` `    ``// Function Call``    ``minOperations(arr, N, Q, M);``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 program for the above approach` `# Function to find the minimum sum``# for each query after removing``# element from either ends till each``# value Q[i]``def` `minOperations(arr, N, Q, M):``  ` `    ``# Stores the prefix sum from``    ``# both the ends of the array``    ``m1 ``=` `{}``    ``m2 ``=` `{}``    ``front ``=` `0``    ``rear ``=` `0``    ` `    ``# Traverse the array from front``    ``for` `i ``in` `range``(N):``        ``front ``+``=` `arr[i]``        ` `        ``# Insert it into the map m1``        ``m1[arr[i]] ``=` `front``    ` `    ``# Traverse the array in reverse``    ``for` `i ``in` `range``(N ``-` `1``, ``-``1``, ``-``1``):``        ``rear ``+``=` `arr[i]``        ` `        ``# Insert it into the map m2``        ``m2[arr[i]] ``=` `rear``    ` `    ``# Traverse the query array``    ``for` `i ``in` `range``(M):``      ` `        ``# Print the minimum of the``        ``# two values as the answer``        ``print``(``min``(m1[Q[i]], m2[Q[i]]),end``=``" "``)` `# Driver Code``arr ``=` `[``2``, ``3``, ``6``, ``7``, ``4``, ``5``, ``1` `]``N ``=` `len``(arr)``Q ``=` `[``7``,``6``]``M ``=` `len``(Q)` `# Function Call``minOperations(arr, N, Q, M)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``    ` `// Function to find the minimum sum``// for each query after removing``// element from either ends till each``// value Q[i]``static` `void` `minOperations(``int``[] arr, ``int` `N,``                          ``int``[] Q, ``int` `M)``{``    ` `    ``// Stores the prefix sum from``    ``// both the ends of the array``    ``Dictionary<``int``,``               ``int``> m1 = ``new` `Dictionary<``int``,``                                        ``int``>();``    ``Dictionary<``int``,``               ``int``> m2 = ``new` `Dictionary<``int``,``                                        ``int``>();` `    ``int` `front = 0, rear = 0;` `    ``// Traverse the array from front``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``front += arr[i];` `        ``// Insert it into the map m1``        ``m1[arr[i]] = front;``    ``}` `    ``// Traverse the array in reverse``    ``for``(``int` `i = N - 1; i >= 0; i--)``    ``{``        ``rear += arr[i];` `        ``// Insert it into the map m2``        ``m2[arr[i]] = rear;``    ``}` `    ``// Traverse the query array``    ``for``(``int` `i = 0; i < M; i++)``    ``{``        ` `        ``// Print the minimum of the``        ``// two values as the answer``        ``Console.Write(Math.Min(m1[Q[i]],``                               ``m2[Q[i]]) + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `Main()``{``    ``int``[] arr = { 2, 3, 6, 7, 4, 5, 1 };``    ``int` `N = arr.Length;``    ``int``[] Q = { 7, 6 };``    ``int` `M = Q.Length;` `    ``// Function Call``    ``minOperations(arr, N, Q, M);``}``}` `// This code is contributed by ukasp`

## Javascript

 ``

Output:

`17 11`

Time Complexity: O(N + M)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up