# 5 Best Ways to Find Maximum Sum by Removing K Numbers from Ends in Python

Rate this post

π‘ Problem Formulation: You are given an array of integers and a number `k`. The challenge is to maximize the sum of numbers by removing exactly `k` elements from either end of the array. For instance, given the array `[1, 2, 3, 4, 5]` and `k = 2`, the maximum sum we can get by removing two elements from the ends is `9` (by removing numbers 1 and 5).

## Method 1: Brute Force

This method involves generating all possible subsets after removing `k` numbers from either end and then calculating their sums to find the max sum. While straightforward and easy to understand, it is highly inefficient with a time complexity of O(2^k).

Here’s an example:

```def max_sum_brute_force(arr, k):
max_sum = float('-inf')
for i in range(k + 1):
for j in range(k - i + 1):
curr_sum = sum(arr[i:len(arr) - j])
max_sum = max(max_sum, curr_sum)
return max_sum

print(max_sum_brute_force([1, 2, 3, 4, 5], 2))
```

Output:

```9
```

This function computes all possible sums obtained by removing up to `k` elements from the array and records the maximum sum. It uses nested loops to achieve this, which leads to a significant increase in runtime for large `k` values.

## Method 2: Recursive Approach

In this method, we reduce the problem size in each recursive call by removing an element from either end. We return the maximum of those two results. It relies on the recursive nature of the problem but suffers from overlapping subproblems and a lack of memoization.

Here’s an example:

```def max_sum_recursive(arr, k):
if k == 0:
return sum(arr)
if len(arr) == k:
return 0
return max(max_sum_recursive(arr[1:], k - 1), max_sum_recursive(arr[:-1], k - 1))

print(max_sum_recursive([1, 2, 3, 4, 5], 2))
```

Output:

```9
```

This recursive code snippet solves the problem in a Top-Down approach by solving bigger problems by breaking them down into smaller problems and using recursion to solve the smaller problems. However, it is not efficient for larger arrays or large values of `k` due to redundant calculations.

## Method 3: Dynamic Programming

Dynamic programming (DP) provides an efficient solution by storing the results of subproblems to avoid redundant calculations. The method involves filling a DP table that helps derive the maximum sum with optimal substructure. It significantly improves the time complexity to O(n*k).

Here’s an example:

```def max_sum_dp(arr, k):
n = len(arr)
dp = [0] * (n+1)
for i in range(1, n+1):
dp[i] = dp[i-1] + arr[i-1]
max_sum = float('-inf')
for i in range(k+1):
current = dp[n] - dp[i] - (dp[n-k+i] - dp[i])
max_sum = max(max_sum, current)
return max_sum

print(max_sum_dp([1, 2, 3, 4, 5], 2))
```

Output:

```9
```

This DP solution calculates the prefix sum to avoid repeated summation and then iterates over possible removals of elements from either end, referencing the precomputed sums for efficient calculation of each total sum.

## Method 4: Sliding Window Approach

The sliding window approach is an upgrade over the brute force method where the window size is fixed to the size of the array minus `k`. The maximum sum of such a window gives us the result. This method is much more efficient than the previous ones with a runtime complexity of O(n).

Here’s an example:

```def max_sum_sliding_window(arr, k):
window_sum = sum(arr[:len(arr)-k])
max_sum = window_sum
for i in range(1, k+1):
window_sum = window_sum - arr[len(arr)-k+i-1] + arr[i-1]
max_sum = max(max_sum, window_sum)
return max_sum

print(max_sum_sliding_window([1, 2, 3, 4, 5], 2))
```

Output:

```9
```

The sliding window code snippet works by calculating the sum of the initial window and sliding it across the array, updating the sum and keeping track of the maximum sum encountered through the sliding process. It’s both easy to understand and efficient for large arrays.

## Bonus One-Liner Method 5: Pythonic Approach Using Slicing

Python offers slicing which can be used to create a one-liner that is both elegant and effective. However, it is not as efficient as the sliding window approach for large arrays, but its conciseness is noteworthy.

Here’s an example:

```max_sum_one_liner = lambda arr, k: max(sum(arr[i:i+len(arr)-k]) for i in range(k+1))

print(max_sum_one_liner([1, 2, 3, 4, 5], 2))
```

Output:

```9
```

This one-liner uses a generator expression within the `max()` function to iterate over all possible ways of removing `k` elements from either end and calculates the sum for each. It’s simple and utilizes Python’s powerful slicing and iteration capabilities in one line.

## Summary/Discussion

• Method 1: Brute Force. Straightforward. Not optimal for large inputs due to its O(2^k) time complexity.
• Method 2: Recursive Approach. Easy to understand. Not efficient due to overlapping subproblems and no memoization.
• Method 3: Dynamic Programming. Efficient for large inputs. Requires understanding of DP and optimal substructure.
• Method 4: Sliding Window Approach. Optimal with O(n) time complexity. Combines simplicity and efficiency.
• Method 5: Pythonic Approach. Concise and elegant, best for quick implementation but not the most efficient for large arrays.