Related Articles
Min steps to empty an Array by removing a pair each time with sum at most K
• Last Updated : 05 Aug, 2020

Given an array arr[] and a target value K. The task is to find the minimum number of steps required to take all elements from the array. In each step, at most two elements can be selected from array such that their sum must not exceed target value K
Note: All the elements of the array are less than or equals to K.

Input: arr[] = [5, 1, 5, 4], K = 8
Output:
Explanation:
We can pick {1, 4}, {5}, {5} in 3 steps:
Other possible arrangement can be {1, 5}, {4}, {5} in three steps.
So, the minimum number of steps are required is 3

Input: [1, 2, 1, 1, 3], n = 9
Output:
Explanation:
We can pick {1, 1}, {2, 3} and {1} in three steps.
Other possible choices {1, 3}, {1, 2}, {1} or {1, 1}, {1, 3}, {2}
So, the minimum number of steps are required is 3

Approach: The above problem can be solved using Greedy Approach along with Two Pointers Technique. The idea is to pick the smallest and the largest element from the array and check if the sum doesn’t exceeds N then remove these element and count this step else remove the largest element and then repeat the above steps until all elements are removed. Below are the steps:

1. Sort the given array arr[].
2. Intialize two index i = 0 and j = N – 1.
3. If the sum of elements arr[i] and arr[j] doesn’t exceeds N then increment i and decrement j.
4. Else decrement j.
5. Repeat the above steps till i <= j and count each steps.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ``#include  ``using` `namespace` `std; `` ` `// Function to count minimum steps ``int` `countMinSteps(``int` `arr[], ``int` `target, ``                ``int` `n) ``{ `` ` `    ``// Function to sort the array ``    ``sort(arr, arr + n); ``    ``int` `minimumSteps = 0; ``    ``int` `i = 0, j = n - 1; `` ` `    ``// Run while loop ``    ``while` `(i <= j) { `` ` `        ``// Condition to check whether ``        ``// sum exceed the target or not ``        ``if` `(arr[i] + arr[j] <= target) { ``            ``i++; ``            ``j--; ``        ``} ``        ``else` `{ ``            ``j--; ``        ``} `` ` `        ``// Increment the step ``        ``// by 1 ``        ``minimumSteps++; ``    ``} `` ` `    ``// Return minimum steps ``    ``return` `minimumSteps; ``} `` ` `// Driver Code ``int` `main() ``{ ``    ``// Given array arr[] ``    ``int` `arr[] = { 4, 6, 2, 9, 6, 5, 8, 10 }; `` ` `    ``// Given target value ``    ``int` `target = 11; `` ` `    ``int` `size = ``sizeof``(arr) / ``sizeof``(arr); `` ` `    ``// Function call ``    ``cout << countMinSteps(arr, target, size); `` ` `    ``return` `0; ``} `

## Java

 `// Java program implementation``// of the above approach``import` `java.util.*;``import` `java.io.*;`` ` `class` `GFG{`` ` `// Function to count minimum steps     ``static` `int` `countMinSteps(``int` `arr[],``                         ``int` `target, ``                         ``int` `n) ``{``     ` `    ``// Function to sort the array``    ``Arrays.sort(arr);`` ` `    ``int` `minimumSteps = ``0``;``    ``int` `i = ``0``;``    ``int` `j = n - ``1``;`` ` `    ``// Run while loop``    ``while` `(i <= j)``    ``{``         ` `        ``// Condition to check whether ``        ``// sum exceed the target or not``        ``if` `(arr[i] + arr[j] <= target)``        ``{``            ``i += ``1``;``            ``j -= ``1``;``        ``}``        ``else` `        ``{``            ``j -= ``1``;``        ``}``     ` `        ``// Increment the step by 1 ``        ``minimumSteps += ``1``;``    ``}`` ` `    ``// Return minimum steps``    ``return` `minimumSteps;``}`` ` `// Driver code ``public` `static` `void` `main(String[] args) ``{``    ``int` `arr[] = { ``4``, ``6``, ``2``, ``9``, ``6``, ``5``, ``8``, ``10` `};`` ` `    ``// Given target value``    ``int` `target = ``11``;`` ` `    ``int` `size = arr.length;``         ` `    ``// Print the minimum flip``    ``System.out.print(countMinSteps(arr, target,``                                        ``size));``}``}`` ` `// This code is contributed by code_hunt`

## Python3

 `# Python3 program for the above approach `` ` `# Function to count minimum steps ``def` `countMinSteps(arr, target, n):``     ` `    ``# Function to sort the array ``    ``arr.sort()`` ` `    ``minimumSteps ``=` `0``    ``i, j ``=` `0``, n ``-` `1``     ` `    ``# Run while loop``    ``while` `i <``=` `j:``         ` `        ``# Condition to check whether ``        ``# sum exceed the target or not``        ``if` `arr[i] ``+` `arr[j] <``=` `target:``            ``i ``+``=` `1``            ``j ``-``=` `1``        ``else``:``            ``j ``-``=` `1``             ` `        ``# Increment the step ``        ``# by 1 ``        ``minimumSteps ``+``=` `1``         ` `    ``# Return minimum steps``    ``return` `minimumSteps`` ` `# Driver code``     ` `# Given array arr[]``arr ``=` `[ ``4``, ``6``, ``2``, ``9``, ``6``, ``5``, ``8``, ``10` `]``     ` `# Given target value``target ``=` `11`` ` `size ``=` `len``(arr)``     ` `# Function call``print``(countMinSteps(arr, target, size))`` ` `# This code is contributed by Stuti Pathak`

## C#

 `// C# program implementation``// of the above approach``using` `System;`` ` `class` `GFG{`` ` `// Function to count minimum steps     ``static` `int` `countMinSteps(``int``[] arr,``                         ``int` `target, ``                         ``int` `n) ``{``     ` `    ``// Function to sort the array``    ``Array.Sort(arr);`` ` `    ``int` `minimumSteps = 0;``    ``int` `i = 0;``    ``int` `j = n - 1;`` ` `    ``// Run while loop``    ``while` `(i <= j)``    ``{``         ` `        ``// Condition to check whether ``        ``// sum exceed the target or not``        ``if` `(arr[i] + arr[j] <= target)``        ``{``            ``i += 1;``            ``j -= 1;``        ``}``        ``else``        ``{``            ``j -= 1;``        ``}`` ` `        ``// Increment the step by 1 ``        ``minimumSteps += 1;``    ``}`` ` `    ``// Return minimum steps``    ``return` `minimumSteps;``}`` ` `// Driver code ``public` `static` `void` `Main() ``{``    ``int``[] arr = ``new` `int``[]{ 4, 6, 2, 9, ``                           ``6, 5, 8, 10 };`` ` `    ``// Given target value``    ``int` `target = 11;`` ` `    ``int` `size = arr.Length;``     ` `    ``// Print the minimum flip``    ``Console.Write(countMinSteps(``                  ``arr, target, size));``}``}`` ` `// This code is contributed by sanjoy_62`

Output:
`5`

Time Complexity: O(N*log N)
Auxiliary Space: O(1)

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.

My Personal Notes arrow_drop_up