Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Remove k corner elements to maximize remaining sum

  • Difficulty Level : Basic
  • Last Updated : 31 Aug, 2021

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 = 4 
Output : 206 
Explanation :: 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 Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input : arr[] = [1, 2, 3, 4, 5, 6, 1], k = 3 
Output : 18 
Explanation :: 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)



My Personal Notes
arrow_drop_up
Next

Maximize sum of K corner elements in Array
Recommended Articles
Page :
Maximize sum of atmost K elements in array by taking only corner elements | Set 2
08, May 20
Maximize sum of K corner elements in Array
05, May 20
Maximize sum of remaining elements after every removal of the array half with greater sum
14, Sep 20
Maximize Bitwise AND of first element with complement of remaining elements for any permutation of given Array
25, Aug 20
Maximize difference between the sum of absolute differences of each element with the remaining array
24, Jan 21
Minimum number of elements to be removed such that the sum of the remaining elements is equal to k
22, Apr 19
Count the subarray with sum strictly greater than the sum of remaining elements
26, Jan 20
Check if an Array can be Sorted by picking only the corner Array elements
12, Aug 20
Average of remaining elements after removing K largest and K smallest elements from array
17, Dec 18
Find last two remaining elements after removing median of any 3 consecutive elements repeatedly
09, Jan 20
Longest remaining array of distinct elements possible after repeated removal of maximum and minimum elements of triplets
06, Aug 21
Modify array by removing M smallest elements maintaining the order of remaining elements
29, Jun 21
Check if the array has an element which is equal to sum of all the remaining elements
21, Nov 18
Element equal to the sum of all the remaining elements
27, Nov 18
Maximum product of the remaining pair after repeatedly replacing pairs of adjacent array elements with their sum
10, Feb 21
Minimum size of subset of pairs whose sum is at least the remaining array elements
01, Oct 21
Length of smallest subarray to be removed to make sum of remaining elements divisible by K
29, Oct 20
Form a number using corner digits of powers
26, Mar 18
Longest subsequence having greater corner values
12, Feb 19
Remove array end element to maximize the sum of product
24, Sep 17
Last element remaining after repeated removal of Array elements at perfect square indices
25, Aug 21
Check if the array has an element which is equal to product of remaining elements
26, Nov 18
Count remaining array elements after reversing binary representation of each array element
16, Feb 21
Check if the array has an element which is equal to XOR of remaining elements
17, Sep 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
cipher_38
@cipher_38
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!