Minimum number of elements to be removed such that the sum of the remaining elements is equal to k
Last Updated :
05 Aug, 2021
Given an array arr[] of integers and an integer k, the task is to find the minimum number of integers that need to be removed from the array such that the sum of the remaining elements is equal to k. If we cannot get the required sum the print -1.
Examples:
Input: arr[] = {1, 2, 3}, k = 3
Output: 1
Either remove 1 and 2 to reduce the array to {3}
or remove 3 to get the array {1, 2}. Both have equal sum i.e. 3
But removing 3 requires only a single removal.
Input: arr[] = {1, 3, 2, 5, 6}, k = 5
Output: 3
Approach: The idea is to use a sliding window and variables j initialize it to 0, min_num to store the answer and sum to store the current sum. Keep on adding the elements of the array to the variable sum, till it becomes greater than or equal to k, if it is equal to k, then update the min_num as minimum of min_num and (n -(i+1) +j) where n is the number of integers in array and i is the current index, else if it is greater than k, then start decrementing the sum by removing the values of the array from sum till the sum becomes less than or equal to k and also increment the value of j, if sum is equal to k, then once again update min_num. Repeat this whole process till the end of the array.
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 minimum number of
// integers that need to be removed from the
// array to form a sub-array with sum k
int FindMinNumber(int arr[], int n, int k)
{
int i = 0;
int j = 0;
// Stores the minimum number of
// integers that need to be removed
// from the array
int min_num = INT_MAX;
bool found = false;
int sum = 0;
while (i < n) {
sum = sum + arr[i];
// If current sum is equal to
// k, update min_num
if (sum == k) {
min_num = min(min_num, ((n - (i + 1)) + j));
found = true;
}
// If current sum is greater than k
else if (sum > k) {
// Decrement the sum until it
// becomes less than or equal to k
while (sum > k) {
sum = sum - arr[j];
j++;
}
if (sum == k) {
min_num = min(min_num, ((n - (i + 1)) + j));
found = true;
}
}
i++;
}
if (found)
return min_num;
return -1;
}
// Driver code
int main()
{
int arr[] = { 1, 3, 2, 5, 6 };
int n = sizeof(arr) / sizeof(int);
int k = 5;
cout << FindMinNumber(arr, n, k);
return 0;
}
// Java implementation of the approach
class GFG
{
// Function to return the minimum number of
// integers that need to be removed from the
// array to form a sub-array with sum k
static int FindMinNumber(int arr[], int n, int k)
{
int i = 0;
int j = 0;
// Stores the minimum number of
// integers that need to be removed
// from the array
int min_num = Integer.MAX_VALUE;
boolean found = false;
int sum = 0;
while (i < n)
{
sum = sum + arr[i];
// If current sum is equal to
// k, update min_num
if (sum == k)
{
min_num = Math.min(min_num,
((n - (i + 1)) + j));
found = true;
}
// If current sum is greater than k
else if (sum > k)
{
// Decrement the sum until it
// becomes less than or equal to k
while (sum > k)
{
sum = sum - arr[j];
j++;
}
if (sum == k)
{
min_num = Math.min(min_num,
((n - (i + 1)) + j));
found = true;
}
}
i++;
}
if (found)
return min_num;
return -1;
}
// Driver code
public static void main(String[] args)
{
int arr[] = { 1, 3, 2, 5, 6 };
int n = arr.length;
int k = 5;
System.out.println(FindMinNumber(arr, n, k));
}
}
// This code is contributed by Code_Mech
# Python3 implementation of the approach
# Function to return the minimum number of
# integers that need to be removed from the
# array to form a sub-array with Sum k
def FindMinNumber(arr, n, k):
i = 0
j = 0
# Stores the minimum number of
# integers that need to be removed
# from the array
min_num = 10**9
found = False
Sum = 0
while (i < n):
Sum = Sum + arr[i]
# If current Sum is equal to
# k, update min_num
if (Sum == k):
min_num = min(min_num,
((n - (i + 1)) + j))
found = True
# If current Sum is greater than k
elif (Sum > k):
# Decrement the Sum until it
# becomes less than or equal to k
while (Sum > k):
Sum = Sum - arr[j]
j += 1
if (Sum == k):
min_num = min(min_num,
((n - (i + 1)) + j))
found = True
i += 1
if (found):
return min_num
return -1
# Driver code
arr = [1, 3, 2, 5, 6]
n = len(arr)
k = 5
print(FindMinNumber(arr, n, k))
# This code is contributed by mohit kumar
// C# implementation of the approach
using System;
class GFG
{
// Function to return the minimum number of
// integers that need to be removed from the
// array to form a sub-array with sum k
static int FindMinNumber(int[] arr, int n, int k)
{
int i = 0;
int j = 0;
// Stores the minimum number of
// integers that need to be removed
// from the array
int min_num = int.MaxValue;
bool found = false;
int sum = 0;
while (i < n)
{
sum = sum + arr[i];
// If current sum is equal to
// k, update min_num
if (sum == k)
{
min_num = Math.Min(min_num,
((n - (i + 1)) + j));
found = true;
}
// If current sum is greater than k
else if (sum > k)
{
// Decrement the sum until it
// becomes less than or equal to k
while (sum > k)
{
sum = sum - arr[j];
j++;
}
if (sum == k)
{
min_num = Math.Min(min_num,
((n - (i + 1)) + j));
found = true;
}
}
i++;
}
if (found)
return min_num;
return -1;
}
// Driver code
public static void Main()
{
int[] arr = { 1, 3, 2, 5, 6 };
int n = arr.Length;
int k = 5;
Console.WriteLine(FindMinNumber(arr, n, k));
}
}
// This code is contributed by Code_Mech
<?php
// PHP implementation of the approach
// Function to return the minimum number of
// integers that need to be removed from the
// array to form a sub-array with sum k
function FindMinNumber($arr,$n,$k)
{
$i = 0;
$j = 0;
// Stores the minimum number of
// integers that need to be removed
// from the array
$min_num = PHP_INT_MAX;
$found = false;
$sum = 0;
while ($i < $n)
{
$sum = $sum + $arr[$i];
// If current sum is equal to
// k, update min_num
if ($sum == $k)
{
$min_num = min($min_num,
(($n - ($i + 1)) + $j));
$found = true;
}
// If current sum is greater than k
else if ($sum > $k)
{
// Decrement the sum until it
// becomes less than or equal to k
while ($sum > $k)
{
$sum = $sum - $arr[$j];
$j++;
}
if ($sum == $k)
{
$min_num =min($min_num,
(($n - ($i + 1)) + $j));
$found = true;
}
}
$i++;
}
if ($found)
return $min_num;
return -1;
}
// Driver code
$arr = array( 1, 3, 2, 5, 6 );
$n = sizeof($arr);
$k = 5;
echo(FindMinNumber($arr, $n, $k));
// This code is contributed by Code_Mech
<script>
// Javascript implementation of the approach
// Function to return the minimum number of
// integers that need to be removed from the
// array to form a sub-array with sum k
function FindMinNumber(arr,n,k)
{
let i = 0;
let j = 0;
// Stores the minimum number of
// integers that need to be removed
// from the array
let min_num = Number.MAX_VALUE;
let found = false;
let sum = 0;
while (i < n)
{
sum = sum + arr[i];
// If current sum is equal to
// k, update min_num
if (sum == k)
{
min_num = Math.min(min_num,
((n - (i + 1)) + j));
found = true;
}
// If current sum is greater than k
else if (sum > k)
{
// Decrement the sum until it
// becomes less than or equal to k
while (sum > k)
{
sum = sum - arr[j];
j++;
}
if (sum == k)
{
min_num = Math.min(min_num,
((n - (i + 1)) + j));
found = true;
}
}
i++;
}
if (found)
return min_num;
return -1;
}
// Driver code
let arr = [1, 3, 2, 5, 6 ];
let n = arr.length;
let k = 5;
document.write(FindMinNumber(arr, n, k));
// This code is contributed by patel2127
</script>
Time Complexity: O(N)
Auxiliary Space: O(1)
Similar Reads
Maximum elements that can be removed from front of two arrays such that their sum is at most K Given an integer K and two arrays A[] and B[] consisting of N and M integers, the task is to maximize the number of elements that can be removed from the front of either array according to the following rules: Remove an element from the front of either array A[] and B[] such that the value of the re
15+ min read
Minimize count of array elements to be removed such that at least K elements are equal to their index values Given an array arr[](1- based indexing) consisting of N integers and a positive integer K, the task is to find the minimum number of array elements that must be removed such that at least K array elements are equal to their index values. If it is not possible to do so, then print -1. Examples: Input
13 min read
Find the minimum number of elements that should be removed to make an array good Given an array of size N and an integer K. The array consists of only digits {0, 1, 2, 3, ...k-1}. The task is to make array good by removing some of the elements. The array of length x is called good if x is divisible by k and one can split the given array into x/k subsequences and each of form {0,
6 min read
Length of smallest subarray to be removed to make sum of remaining elements divisible by K Given an array arr[] of integers and an integer K, the task is to find the length of the smallest subarray that needs to be removed such that the sum of remaining array elements is divisible by K. Removal of the entire array is not allowed. If it is impossible, then print "-1". Examples: Input: arr[
11 min read
Minimum pairs required to be removed such that the array does not contain any pair with sum K Given an array arr[] of size N and an integer K, the task is to find the minimum count of pairs required to be removed such that no pair exists in the array whose sum of elements is equal to K. Examples: Input: arr[] = { 3, 1, 3, 4, 3 }, K = 6 Output: 1 Explanation: Removing the pair (arr[0], arr[2]
7 min read
Min sum of set of positive integers so that sum of no two elements is K Given two positive integers N and K. Create a set of size N containing distinct positive integers such that the sum of no two integers is K, the task is to find the minimum possible sum of the set that meets the above criteria. Since the answer may be large, print it modulo 10^9+7. Note: It is guara
6 min read