Given an array **arr[]** consisting of **N** elements, the task is to remove minimum number of elements from the ends of the array such that the total sum of the array decreases by at least **K**. **Note** that **K** will always be less than or equal to the sum of all the elements of the array.**Examples:**

Input:arr[] = {1, 11, 5, 5}, K = 11Output:2

After removing two elements form the left

end, the sum decreases by 1 + 11 = 12.

Thus, the answer is 2.Input:arr[] = {1, 2, 3}, K = 6Output:3

**Approach:** A dynamic programming based approach has already been discussed in another post. In this article, an approach using the two-pointer technique will be discussed. It can be observed that the task is to find the longest sub-array with the sum of its elements at most **sum(arr) – K** where **sum(arr)** is the sum of all the elements of the array **arr[]**.

Let the length of such subarray be **L**. Thus, the minimum number of elements to be removed from the array will be equal to **N – L**. To find the length of longest such subarray, refer this article.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return the count of minimum` `// elements to be removed from the ends` `// of the array such that the sum of the` `// array decrease by at least K` `int` `minCount(` `int` `* arr, ` `int` `n, ` `int` `k)` `{` ` ` `// To store the final answer` ` ` `int` `ans = 0;` ` ` `// Maximum possible sum required` ` ` `int` `sum = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `sum += arr[i];` ` ` `sum -= k;` ` ` `// Left point` ` ` `int` `l = 0;` ` ` `// Right pointer` ` ` `int` `r = 0;` ` ` `// Total current sum` ` ` `int` `tot = 0;` ` ` `// Two pointer loop` ` ` `while` `(l < n) {` ` ` `// If the sum fits` ` ` `if` `(tot <= sum) {` ` ` `// Update the answer` ` ` `ans = max(ans, r - l);` ` ` `if` `(r == n)` ` ` `break` `;` ` ` `// Update the total sum` ` ` `tot += arr[r++];` ` ` `}` ` ` `else` `{` ` ` `// Increment the left pointer` ` ` `tot -= arr[l++];` ` ` `}` ` ` `}` ` ` `return` `(n - ans);` `}` `// Driver code` `int` `main()` `{` ` ` `int` `arr[] = { 1, 11, 5, 5 };` ` ` `int` `n = ` `sizeof` `(arr) / ` `sizeof` `(` `int` `);` ` ` `int` `k = 11;` ` ` `cout << minCount(arr, n, k);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the approach` `class` `GFG` `{` ` ` ` ` `// Function to return the count of minimum` ` ` `// elements to be removed from the ends` ` ` `// of the array such that the sum of the` ` ` `// array decrease by at least K` ` ` `static` `int` `minCount(` `int` `arr[],` ` ` `int` `n, ` `int` `k)` ` ` `{` ` ` ` ` `// To store the final answer` ` ` `int` `ans = ` `0` `;` ` ` ` ` `// Maximum possible sum required` ` ` `int` `sum = ` `0` `;` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `sum += arr[i];` ` ` `sum -= k;` ` ` ` ` `// Left point` ` ` `int` `l = ` `0` `;` ` ` ` ` `// Right pointer` ` ` `int` `r = ` `0` `;` ` ` ` ` `// Total current sum` ` ` `int` `tot = ` `0` `;` ` ` ` ` `// Two pointer loop` ` ` `while` `(l < n)` ` ` `{` ` ` ` ` `// If the sum fits` ` ` `if` `(tot <= sum)` ` ` `{` ` ` ` ` `// Update the answer` ` ` `ans = Math.max(ans, r - l);` ` ` `if` `(r == n)` ` ` `break` `;` ` ` ` ` `// Update the total sum` ` ` `tot += arr[r++];` ` ` `}` ` ` `else` ` ` `{` ` ` ` ` `// Increment the left pointer` ` ` `tot -= arr[l++];` ` ` `}` ` ` `}` ` ` `return` `(n - ans);` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `main (String[] args)` ` ` `{` ` ` `int` `arr[] = { ` `1` `, ` `11` `, ` `5` `, ` `5` `};` ` ` `int` `n = arr.length;` ` ` `int` `k = ` `11` `;` ` ` ` ` `System.out.println(minCount(arr, n, k));` ` ` `}` `}` `// This code is contributed by AnkitRai01` |

## Python3

`# Python3 implementation of the approach` `# Function to return the count of minimum` `# elements to be removed from the ends` `# of the array such that the sum of the` `# array decrease by at least K` `def` `minCount(arr, n, k) :` ` ` `# To store the final answer` ` ` `ans ` `=` `0` `;` ` ` `# Maximum possible sum required` ` ` `sum` `=` `0` `;` ` ` `for` `i ` `in` `range` `(n) :` ` ` `sum` `+` `=` `arr[i];` ` ` `sum` `-` `=` `k;` ` ` `# Left point` ` ` `l ` `=` `0` `;` ` ` `# Right pointer` ` ` `r ` `=` `0` `;` ` ` `# Total current sum` ` ` `tot ` `=` `0` `;` ` ` `# Two pointer loop` ` ` `while` `(l < n) :` ` ` `# If the sum fits` ` ` `if` `(tot <` `=` `sum` `) :` ` ` `# Update the answer` ` ` `ans ` `=` `max` `(ans, r ` `-` `l);` ` ` `if` `(r ` `=` `=` `n) :` ` ` `break` `;` ` ` `# Update the total sum` ` ` `tot ` `+` `=` `arr[r];` ` ` `r ` `+` `=` `1` ` ` ` ` `else` `:` ` ` `# Increment the left pointer` ` ` `tot ` `-` `=` `arr[l];` ` ` `l ` `+` `=` `1` ` ` ` ` `return` `(n ` `-` `ans);` `# Driver code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `arr ` `=` `[ ` `1` `, ` `11` `, ` `5` `, ` `5` `];` ` ` `n ` `=` `len` `(arr);` ` ` `k ` `=` `11` `;` ` ` `print` `(minCount(arr, n, k));` `# This code is contributed by AnkitRai01` |

## C#

`// C# implementation of the approach` `using` `System;` `class` `GFG` `{` ` ` ` ` `// Function to return the count of minimum` ` ` `// elements to be removed from the ends` ` ` `// of the array such that the sum of the` ` ` `// array decrease by at least K` ` ` `static` `int` `minCount(` `int` `[]arr,` ` ` `int` `n, ` `int` `k)` ` ` `{` ` ` ` ` `// To store the final answer` ` ` `int` `ans = 0;` ` ` ` ` `// Maximum possible sum required` ` ` `int` `sum = 0;` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `sum += arr[i];` ` ` `sum -= k;` ` ` ` ` `// Left point` ` ` `int` `l = 0;` ` ` ` ` `// Right pointer` ` ` `int` `r = 0;` ` ` ` ` `// Total current sum` ` ` `int` `tot = 0;` ` ` ` ` `// Two pointer loop` ` ` `while` `(l < n)` ` ` `{` ` ` ` ` `// If the sum fits` ` ` `if` `(tot <= sum)` ` ` `{` ` ` ` ` `// Update the answer` ` ` `ans = Math.Max(ans, r - l);` ` ` `if` `(r == n)` ` ` `break` `;` ` ` ` ` `// Update the total sum` ` ` `tot += arr[r++];` ` ` `}` ` ` `else` ` ` `{` ` ` ` ` `// Increment the left pointer` ` ` `tot -= arr[l++];` ` ` `}` ` ` `}` ` ` `return` `(n - ans);` ` ` `}` ` ` ` ` `// Driver code` ` ` `public` `static` `void` `Main()` ` ` `{` ` ` `int` `[]arr = { 1, 11, 5, 5 };` ` ` `int` `n = arr.Length;` ` ` `int` `k = 11;` ` ` ` ` `Console.WriteLine(minCount(arr, n, k));` ` ` `}` `}` `// This code is contributed by AnkitRai01` |

## Javascript

`<script>` `// Javascript implementation of the approach` `// Function to return the count of minimum` `// elements to be removed from the ends` `// of the array such that the sum of the` `// array decrease by at least K` `function` `minCount(arr, n, k)` `{` ` ` `// To store the final answer` ` ` `var` `ans = 0;` ` ` `// Maximum possible sum required` ` ` `var` `sum = 0;` ` ` `for` `(` `var` `i = 0; i < n; i++)` ` ` `sum += arr[i];` ` ` `sum -= k;` ` ` `// Left point` ` ` `var` `l = 0;` ` ` `// Right pointer` ` ` `var` `r = 0;` ` ` `// Total current sum` ` ` `var` `tot = 0;` ` ` `// Two pointer loop` ` ` `while` `(l < n) {` ` ` `// If the sum fits` ` ` `if` `(tot <= sum) {` ` ` `// Update the answer` ` ` `ans = Math.max(ans, r - l);` ` ` `if` `(r == n)` ` ` `break` `;` ` ` `// Update the total sum` ` ` `tot += arr[r++];` ` ` `}` ` ` `else` `{` ` ` `// Increment the left pointer` ` ` `tot -= arr[l++];` ` ` `}` ` ` `}` ` ` `return` `(n - ans);` `}` `// Driver code` `var` `arr = [1, 11, 5, 5 ];` `var` `n = arr.length;` `var` `k = 11;` `document.write( minCount(arr, n, k));` `// This code is contributed by noob2000.` `</script>` |

**Output:**

2

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 industry experts, please refer **Geeks Classes Live** and **Geeks Classes Live USA**