Skip to content
Related Articles

Related Articles

Remove minimum elements from ends of array so that sum decreases by at least K | O(N)

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 13 May, 2021
Improve Article
Save Article

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 = 11 
Output:
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 = 6 
Output:
 

 

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

 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!