# Remove k corner elements to maximize remaining sum

Given an array, the task is to remove total k elements from corners to maximize the sum of remaining elements. For example, if we k = 5 and if we remove 2 elements from the left corner, then we need to remove 3 elements from the right corner.**Examples:**

Input: arr = [11, 49, 100, 20, 86, 29, 72], k = 4Output: 206Explanation :: We remove 29 and 72 from right corner. We also remove 11 and 49 from left corner to get the maximum sum as 206 for remaining elements.Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the

DSA Self Paced Courseat a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please referComplete Interview Preparation Course.In case you wish to attend

live classeswith experts, please referDSA Live Classes for Working ProfessionalsandCompetitive Programming Live for Students.

Input: arr[] = [1, 2, 3, 4, 5, 6, 1], k = 3Output :18Explanation :: We remove two elements from left corner (1 and 2) and one element from right corner (1).

**Naive Approach : **

1) Initialize result as negative infinity.

2) Compute total sum.

3) Run a loop for x = 1 to k

…..Remove ‘x’ elements from left side and k – i elements from right side.

…..If the remaining elements have sum more than the result, update the result.

Time Complexity: O(n * k)**Efficient Approach (Using ****Window Sliding**** Technique)**

1) Find the sum of first n-k elements and initialize this as a current sum and also initialize this as result.

2) Run a loop for i = n-k to n-1

….curr_sum = curr_sum – arr[i – n + k] + arr[i]

….res = max(res, curr_sum)

In step 2, we mainly run sliding window. We remove an element from left side and add an element from right side.

Below is the c++ implementation of the above problem statement.

## C++

`#include <bits/stdc++.h>` `using` `namespace` `std;` `int` `calculate(` `int` `arr[], ` `int` `n, ` `int` `k)` `{` ` ` `// Calculate the sum of all elements` ` ` `// excluding the last k elements..` ` ` `int` `curr_sum = 0;` ` ` `for` `(` `int` `i = 0; i < n - k; i++)` ` ` `curr_sum += arr[i];` ` ` `// now here its time to use sliding window` ` ` `// concept, remove the first element from` ` ` `// the current window and add the new element` ` ` `// in it in order to get the sum of all n-k size` ` ` `// of elements in arr.` ` ` `// Calculate the minimum sum of elements of` ` ` `// size n-k and stored it into the result` ` ` `int` `res = curr_sum;` ` ` `for` `(` `int` `i = n - k; i < n; i++) {` ` ` `curr_sum = curr_sum - arr[i - n + k] + arr[i];` ` ` `res = max(res, curr_sum);` ` ` `}` ` ` `// Now return result (sum of remaining n-k elements)` ` ` `return` `res;` `}` `// main function` `int` `main()` `{` ` ` `int` `arr[] = { 11, 49, 100, 20, 86, 29, 72 };` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `int` `k = 4;` ` ` `cout << ` `"Maximum sum of remaining elements "` ` ` `<< calculate(arr, n, k) << ` `"\n"` `;` ` ` `return` `0;` `}` |

## Java

`// Java program for the` `// above approach` `import` `java.util.*;` `class` `GFG{` `static` `int` `calculate(` `int` `[] arr,` ` ` `int` `n, ` `int` `k)` `{` ` ` `// Calculate the total` ` ` `// sum of all elements` ` ` `// present in the array..` ` ` `int` `total_sum = ` `0` `;` ` ` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `total_sum += arr[i];` ` ` `// Now calculate the sum` ` ` `// of all elements excluding` ` ` `// the last k elements..` ` ` `int` `curr_sum = ` `0` `;` ` ` ` ` `for` `(` `int` `i = ` `0` `; i < n - k; i++)` ` ` `curr_sum += arr[i];` ` ` `// Now here its time to use` ` ` `// sliding window concept,` ` ` `// remove the first element` ` ` `// from the current window` ` ` `// and add the new element` ` ` `// in it in order to get` ` ` `// the sum of all n-k size` ` ` `// of elements in arr.` ` ` `// Calculate the minimum` ` ` `// sum of elements of` ` ` `// size n-k and stored it` ` ` `// into the result` ` ` `int` `res = curr_sum;` ` ` ` ` `for` `(` `int` `i = n - k; i < n; i++)` ` ` `{` ` ` `curr_sum = curr_sum -` ` ` `arr[i - n + k] +` ` ` `arr[i];` ` ` `res = Math.max(res, curr_sum);` ` ` `}` ` ` `// Now return result (sum of` ` ` `// remaining n-k elements)` ` ` `return` `res;` `}` `// Driver code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `[] arr = {` `11` `, ` `49` `, ` `100` `,` ` ` `20` `, ` `86` `, ` `29` `, ` `72` `};` ` ` `int` `n = arr.length;` ` ` `int` `k = ` `4` `;` ` ` `System.out.print(` `"Maximum sum of remaining "` `+` ` ` `"elements "` `+` ` ` `calculate(arr, n, k) + ` `"\n"` `);` `}` `}` `// This code is contributed by Chitranayal` |

## Python3

`def` `calculate(arr, n, k):` ` ` ` ` `# calculate the total sum of all elements` ` ` `# present in the array..` ` ` `total_sum ` `=` `0` ` ` `for` `i ` `in` `arr:` ` ` `total_sum ` `+` `=` `i` ` ` `# now calculate the sum of all elements` ` ` `# excluding the last k elements..` ` ` `curr_sum ` `=` `0` ` ` `for` `i ` `in` `range` `(n ` `-` `k):` ` ` `curr_sum ` `+` `=` `arr[i]` ` ` `# now here its time to use sliding window` ` ` `# concept, remove the first element from` ` ` `# the current window and add the new element` ` ` `# in it in order to get the sum of all n-k size` ` ` `# of elements in arr.` ` ` `# Calculate the minimum sum of elements of` ` ` `# size n-k and stored it into the result` ` ` `res ` `=` `curr_sum` ` ` `for` `i ` `in` `range` `(n ` `-` `k, n):` ` ` `curr_sum ` `=` `curr_sum ` `-` `arr[i ` `-` `n ` `+` `k] ` `+` `arr[i]` ` ` `res ` `=` `max` `(res, curr_sum)` ` ` `# Now return result (sum of remaining n-k elements)` ` ` `return` `res` `# main function` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `arr` `=` `[` `11` `, ` `49` `, ` `100` `, ` `20` `, ` `86` `, ` `29` `, ` `72` `]` ` ` `n ` `=` `len` `(arr)` ` ` `k ` `=` `4` ` ` `print` `(` `"Maximum sum of remaining elements "` `,calculate(arr, n, k))` `# This code is contributed by mohit kumar 29 ` |

## C#

`using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;` `class` `GFG{` ` ` `static` `int` `calculate(` `int` `[]arr, ` `int` `n, ` `int` `k)` `{` ` ` ` ` `// Calculate the total sum of all elements` ` ` `// present in the array..` ` ` `int` `total_sum = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `total_sum += arr[i];` ` ` ` ` `// Now calculate the sum of all elements` ` ` `// excluding the last k elements..` ` ` `int` `curr_sum = 0;` ` ` `for` `(` `int` `i = 0; i < n - k; i++)` ` ` `curr_sum += arr[i];` ` ` ` ` `// Now here its time to use sliding window` ` ` `// concept, remove the first element from` ` ` `// the current window and add the new element` ` ` `// in it in order to get the sum of all n-k size` ` ` `// of elements in arr.` ` ` `// Calculate the minimum sum of elements of` ` ` `// size n-k and stored it into the result` ` ` `int` `res = curr_sum;` ` ` `for` `(` `int` `i = n - k; i < n; i++)` ` ` `{` ` ` `curr_sum = curr_sum -` ` ` `arr[i - n + k] + arr[i];` ` ` `res = Math.Max(res, curr_sum);` ` ` `}` ` ` ` ` `// Now return result (sum of` ` ` `// remaining n-k elements)` ` ` `return` `res;` `}` `// Driver code` `public` `static` `void` `Main(` `string` `[] args)` `{` ` ` `int` `[]arr = { 11, 49, 100, 20, 86, 29, 72 };` ` ` `int` `n = arr.Length;` ` ` `int` `k = 4;` ` ` ` ` `Console.Write(` `"Maximum sum of remaining "` `+` ` ` `"elements "` `+` ` ` `calculate(arr, n, k) + ` `"\n"` `);` `}` `}` `// This code is contributed by rutvik_56` |

## Javascript

`<script>` `function` `calculate(arr, n, k)` `{` ` ` `// calculate the total sum of all elements` ` ` `// present in the array..` ` ` `let total_sum = 0;` ` ` `for` `(let i = 0; i < n; i++)` ` ` `total_sum += arr[i];` ` ` `// now calculate the sum of all elements` ` ` `// excluding the last k elements..` ` ` `let curr_sum = 0;` ` ` `for` `(let i = 0; i < n - k; i++)` ` ` `curr_sum += arr[i];` ` ` `// now here its time to use sliding window` ` ` `// concept, remove the first element from` ` ` `// the current window and add the new element` ` ` `// in it in order to get the sum of all n-k size` ` ` `// of elements in arr.` ` ` `// Calculate the minimum sum of elements of` ` ` `// size n-k and stored it into the result` ` ` `let res = curr_sum;` ` ` `for` `(let i = n - k; i < n; i++) {` ` ` `curr_sum = curr_sum - arr[i - n + k] + arr[i];` ` ` `res = Math.max(res, curr_sum);` ` ` `}` ` ` `// Now return result (sum of remaining n-k elements)` ` ` `return` `res;` `}` `// main function` `let arr = [11, 49, 100, 20, 86, 29, 72];` `let n = arr.length;` `let k = 4;` `document.write(` `"Maximum sum of remaining elements "` `+ calculate(arr, n, k) + ` `"<br>"` `);` `// This code is contributed by gfgking` `</script>` |

**Output:**

Maximum sum of remaining elements 206

**Time Complexity: **O(k) **Auxiliary Space :** O(1)