Minimum removal of elements from end of an array required to obtain sum K
Last Updated :
11 Jul, 2022
Given an integer K and an array A[] of size N, the task is to create a new array with sum K with minimum number of operations, where in each operation, an element can be removed either from the start or end of A[] and appended to the new array. If it is not possible to generate a new array with sum K, print -1. If there are multiple answers, print any one of them.
Examples
Input: K = 6, A[] = {1, 2, 3, 1, 3}, N = 5
Output: 1 3 2
Explanation: Operation 1: Removing A[0] modifies A[] to {2, 3, 1, 3}. Sum = 1.
Operation 2: Removing A[3] modifies A[] to {2, 1, 3}. Sum = 4.
Operation 3: Removing A[0] modifies A[] to {1, 3}. Sum = 6.
Input: K = 5, A[] = {1, 2, 7}, N = 3
Output: -1
Naive Approach: Follow the steps below to solve the problem:
- The task is to find two minimum length subarrays, one from the beginning and one from the end of the array (possibly empty), such that their sum is equal to K.
- Traverse the array from the left and calculate the subarray needed to be removed from the right such that the total sum is K.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find the minimum number of
// elements required to be removed from
// the ends of an array to obtain a sum K
int minSizeArr(int A[], int N, int K)
{
// Number of elements removed from the
// left and right ends of the array
int leftTaken = N, rightTaken = N;
// Sum of left and right subarrays
int leftSum = 0, rightSum = 0;
// No element is taken from left initially
for (int left = -1; left < N; left++) {
if (left != -1)
leftSum += A[left];
rightSum = 0;
// Start taking elements from right side
for (int right = N - 1; right > left; right--) {
rightSum += A[right];
if (leftSum + rightSum == K) {
// (left + 1): Count of elements
// removed from the left
// (N-right): Count of elements
// removed from the right
if (leftTaken + rightTaken
> (left + 1) + (N - right)) {
leftTaken = left + 1;
rightTaken = N - right;
}
break;
}
// If sum is greater than K
if (leftSum + rightSum > K)
break;
}
}
if (leftTaken + rightTaken <= N) {
for (int i = 0; i < leftTaken; i++)
cout << A[i] << " ";
for (int i = 0; i < rightTaken; i++)
cout << A[N - i - 1] << " ";
}
// If it is not possible to obtain sum K
else
cout << -1;
}
// Driver Code
int main()
{
int N = 7;
// Given Array
int A[] = { 3, 2, 1, 1, 1, 1, 3 };
// Given target sum
int K = 10;
minSizeArr(A, N, K);
return 0;
}
// Java program for the above approach
import java.util.*;
class GFG{
// Function to find the minimum number of
// elements required to be removed from
// the ends of an array to obtain a sum K
static void minSizeArr(int A[], int N, int K)
{
// Number of elements removed from the
// left and right ends of the array
int leftTaken = N, rightTaken = N;
// Sum of left and right subarrays
int leftSum = 0, rightSum = 0;
// No element is taken from left initially
for (int left = -1; left < N; left++) {
if (left != -1)
leftSum += A[left];
rightSum = 0;
// Start taking elements from right side
for (int right = N - 1; right > left; right--)
{
rightSum += A[right];
if (leftSum + rightSum == K) {
// (left + 1): Count of elements
// removed from the left
// (N-right): Count of elements
// removed from the right
if (leftTaken + rightTaken
> (left + 1) + (N - right)) {
leftTaken = left + 1;
rightTaken = N - right;
}
break;
}
// If sum is greater than K
if (leftSum + rightSum > K)
break;
}
}
if (leftTaken + rightTaken <= N) {
for (int i = 0; i < leftTaken; i++)
System.out.print( A[i] + " ");
for (int i = 0; i < rightTaken; i++)
System.out.print(A[N - i - 1] + " ");
}
// If it is not possible to obtain sum K
else
System.out.print(-1);
}
// Driver code
public static void main(String[] args)
{
int N = 7;
// Given Array
int A[] = { 3, 2, 1, 1, 1, 1, 3 };
// Given target sum
int K = 10;
minSizeArr(A, N, K);
}
}
// This code is contributed by splevel62.
# Python3 program for the above approach
# Function to find the minimum number of
# elements required to be removed from
# the ends of an array to obtain a sum K
def minSizeArr(A, N, K):
# Number of elements removed from the
# left and right ends of the array
leftTaken = N
rightTaken = N
# Sum of left and right subarrays
leftSum = 0
rightSum = 0
# No element is taken from left initially
for left in range(-1, N):
if (left != -1):
leftSum += A[left]
rightSum = 0
# Start taking elements from right side
for right in range(N - 1, left, -1):
rightSum += A[right]
if (leftSum + rightSum == K):
# (left + 1): Count of elements
# removed from the left
# (N-right): Count of elements
# removed from the right
if (leftTaken + rightTaken >
(left + 1) + (N - right)):
leftTaken = left + 1
rightTaken = N - right
break
# If sum is greater than K
if (leftSum + rightSum > K):
break
if (leftTaken + rightTaken <= N):
for i in range(leftTaken):
print(A[i], end = " ")
for i in range(rightTaken):
print(A[N - i - 1], end = " ")
# If it is not possible to obtain sum K
else:
print(-1)
# Driver Code
if __name__ == "__main__":
N = 7
# Given Array
A = [ 3, 2, 1, 1, 1, 1, 3 ]
# Given target sum
K = 10
minSizeArr(A, N, K)
# This code is contributed by ukasp
// C# program for the above approach
using System;
class GFG {
// Function to find the smallest
// array that can be removed from
// the ends of an array to obtain sum K
static void minSizeArr(int[] A, int N, int K)
{
// Number of elements removed from the
// left and right ends of the array
int leftTaken = N, rightTaken = N;
// Sum of left and right subarrays
int leftSum = 0, rightSum = 0;
// No element is taken from left initially
for (int left = -1; left < N; left++) {
if (left != -1)
leftSum += A[left];
rightSum = 0;
// Start taking elements from right side
for (int right = N - 1; right > left; right--)
{
rightSum += A[right];
if (leftSum + rightSum == K) {
// (left + 1): Count of elements
// removed from the left
// (N-right): Count of elements
// removed from the right
if (leftTaken + rightTaken
> (left + 1) + (N - right)) {
leftTaken = left + 1;
rightTaken = N - right;
}
break;
}
// If sum is greater than K
if (leftSum + rightSum > K)
break;
}
}
if (leftTaken + rightTaken <= N) {
for (int i = 0; i < leftTaken; i++)
Console.Write( A[i] + " ");
for (int i = 0; i < rightTaken; i++)
Console.Write(A[N - i - 1] + " ");
}
// If it is not possible to obtain sum K
else
Console.Write(-1);
}
// Driver Code
public static void Main()
{
int N = 7;
// Given Array
int[] A = { 3, 2, 1, 1, 1, 1, 3 };
// Given target sum
int K = 10;
minSizeArr(A, N, K);
}
}
// This code is contributed by code_hunt.
<script>
// JavaScript program for the above approach
// Function to find the minimum number of
// elements required to be removed from
// the ends of an array to obtain a sum K
function minSizeArr(A, N, K)
{
// Number of elements removed from the
// left and right ends of the array
let leftTaken = N, rightTaken = N;
// Sum of left and right subarrays
let leftSum = 0, rightSum = 0;
// No element is taken from left initially
for (let left = -1; left < N; left++) {
if (left != -1)
leftSum += A[left];
rightSum = 0;
// Start taking elements from right side
for (let right = N - 1; right > left; right--)
{
rightSum += A[right];
if (leftSum + rightSum == K) {
// (left + 1): Count of elements
// removed from the left
// (N-right): Count of elements
// removed from the right
if (leftTaken + rightTaken
> (left + 1) + (N - right)) {
leftTaken = left + 1;
rightTaken = N - right;
}
break;
}
// If sum is greater than K
if (leftSum + rightSum > K)
break;
}
}
if (leftTaken + rightTaken <= N) {
for (let i = 0; i < leftTaken; i++)
document.write( A[i] + " ");
for (let i = 0; i < rightTaken; i++)
document.write(A[N - i - 1] + " ");
}
// If it is not possible to obtain sum K
else
document.write(-1);
}
// Driver code
let N = 7;
// Given Array
let A = [ 3, 2, 1, 1, 1, 1, 3 ];
// Given target sum
let K = 10;
minSizeArr(A, N, K);
// This code is contributed by souraavghosh0416.
</script>
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient Approach: Follow the steps below to optimize the above approach:
- Calculate the sum of elements of the array A[] and store it in a variable, say Total.
- The problem can be seen as finding the maximum size subarray with sum (Total - K).
- The remaining elements will add up to K.
Below is the implementation of the above approach:
C++
// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find the smallest
// array that can be removed from
// the ends of an array to obtain sum K
void minSizeArr(int A[], int N, int K)
{
int sum = 0;
// Sum of complete array
for (int i = 0; i < N; i++)
sum += A[i];
// If given number is greater
// than sum of the array
if (K > sum) {
cout << -1;
return;
}
// If number is equal to
// the sum of array
if (K == sum) {
for (int i = 0; i < N; i++) {
cout << A[i] << " ";
}
return;
}
// tar is sum of middle subarray
int tar = sum - K;
// Find the longest subarray
// with sum equal to tar
unordered_map<int, int> um;
um[0] = -1;
int left, right;
int cur = 0, maxi = -1;
for (int i = 0; i < N; i++) {
cur += A[i];
if (um.find(cur - tar) != um.end()
&& i - um[cur - tar] > maxi) {
maxi = i - um[cur - tar];
right = i;
left = um[cur - tar];
}
if (um.find(cur) == um.end())
um[cur] = i;
}
// If there is no subarray with
// sum equal to tar
if (maxi == -1)
cout << -1;
else {
for (int i = 0; i <= left; i++)
cout << A[i] << " ";
for (int i = 0; i < right; i++)
cout << A[N - i - 1] << " ";
}
}
// Driver Code
int main()
{
int N = 7;
// Given Array
int A[] = { 3, 2, 1, 1, 1, 1, 3 };
// Given target sum
int K = 10;
minSizeArr(A, N, K);
return 0;
}
// Java program for the above approach
import java.io.*;
import java.util.*;
class GFG {
// Function to find the smallest
// array that can be removed from
// the ends of an array to obtain sum K
static void minSizeArr(int A[], int N, int K)
{
int sum = 0;
// Sum of complete array
for (int i = 0; i < N; i++)
sum += A[i];
// If given number is greater
// than sum of the array
if (K > sum) {
System.out.print(-1);
return;
}
// If number is equal to
// the sum of array
if (K == sum) {
for (int i = 0; i < N; i++) {
System.out.print(A[i] + " ");
}
return;
}
// tar is sum of middle subarray
int tar = sum - K;
// Find the longest subarray
// with sum equal to tar
HashMap<Integer, Integer> um = new HashMap<Integer, Integer>();
um.put(0, -1);
int left = 0, right = 0;
int cur = 0, maxi = -1;
for (int i = 0; i < N; i++) {
cur += A[i];
if (um.containsKey(cur - tar)
&& i - um.get(cur - tar) > maxi) {
maxi = i - um.get(cur - tar);
right = i;
left = um.get(cur - tar);
}
if (!um.containsKey(cur))
um.put(cur, i);
}
// If there is no subarray with
// sum equal to tar
if (maxi == -1)
System.out.println(-1);
else {
for (int i = 0; i <= left; i++)
System.out.print(A[i] + " ");
for (int i = 0; i < right; i++)
System.out.print(A[N - i - 1] + " ");
}
}
// Driver Code
public static void main (String[] args) {
int N = 7;
// Given Array
int A[] = { 3, 2, 1, 1, 1, 1, 3 };
// Given target sum
int K = 10;
minSizeArr(A, N, K);
}
}
// This code is contributed by Dharanendra L V.
# python 3 program for the above approach
# Function to find the smallest
# array that can be removed from
# the ends of an array to obtain sum K
def minSizeArr(A, N, K):
sum = 0
# Sum of complete array
for i in range(N):
sum += A[i]
# If given number is greater
# than sum of the array
if (K > sum):
print(-1);
return
# If number is equal to
# the sum of array
if (K == sum):
for i in range(N):
print(A[i],end = " ")
return
# tar is sum of middle subarray
tar = sum - K
# Find the longest subarray
# with sum equal to tar
um = {}
um[0] = -1
left = 0
right = 0
cur = 0
maxi = -1
for i in range(N):
cur += A[i]
if((cur - tar) in um and (i - um[cur - tar]) > maxi):
maxi = i - um[cur - tar]
right = i
left = um[cur - tar]
if(cur not in um):
um[cur] = i
# If there is no subarray with
# sum equal to tar
if (maxi == -1):
print(-1)
else:
for i in range(left+1):
print(A[i], end = " ")
for i in range(right):
print(A[N - i - 1], end = " ")
# Driver Code
if __name__ == '__main__':
N = 7
# Given Array
A = [3, 2, 1, 1, 1, 1, 3]
# Given target sum
K = 10
minSizeArr(A, N, K)
# This code is contributed by SURENDRA_GANGWAR.
// C# program for
// the above approach
using System;
using System.Collections.Generic;
class GFG{
// Function to find the smallest
// array that can be removed from
// the ends of an array to obtain sum K
static void minSizeArr(int[] A, int N, int K)
{
int sum = 0;
// Sum of complete array
for(int i = 0; i < N; i++)
sum += A[i];
// If given number is greater
// than sum of the array
if (K > sum)
{
Console.WriteLine(-1);
return;
}
// If number is equal to
// the sum of array
if (K == sum)
{
for(int i = 0; i < N; i++)
{
Console.Write(A[i] + " ");
}
return;
}
// tar is sum of middle subarray
int tar = sum - K;
// Find the longest subarray
// with sum equal to tar
Dictionary<int,
int> um = new Dictionary<int,
int>();
um[0] = -1;
int left = 0, right = 0;
int cur = 0, maxi = -1;
for(int i = 0; i < N; i++)
{
cur += A[i];
if (um.ContainsKey(cur - tar) &&
i - um[cur - tar] > maxi)
{
maxi = i - um[cur - tar];
right = i;
left = um[cur - tar];
}
if (!um.ContainsKey(cur))
um[cur] = i;
}
// If there is no subarray with
// sum equal to tar
if (maxi == -1)
Console.Write(-1);
else
{
for(int i = 0; i <= left; i++)
Console.Write(A[i] + " ");
for(int i = 0; i < right; i++)
Console.Write(A[N - i - 1] + " ");
}
}
// Driver code
static public void Main()
{
int N = 7;
// Given Array
int[] A = { 3, 2, 1, 1, 1, 1, 3 };
// Given target sum
int K = 10;
minSizeArr(A, N, K);
}
}
// This code is contributed by offbeat
<script>
// JavaScript program for the above approach
// Function to find the smallest
// array that can be removed from
// the ends of an array to obtain sum K
function minSizeArr(A, N, K)
{
var sum = 0;
var i;
// Sum of complete array
for (i = 0; i < N; i++)
sum += A[i];
// If given number is greater
// than sum of the array
if (K > sum) {
cout << -1;
return;
}
// If number is equal to
// the sum of array
if (K == sum) {
for (i = 0; i < N; i++) {
document.write(A[i]+' ');
}
return;
}
// tar is sum of middle subarray
var tar = sum - K;
// Find the longest subarray
// with sum equal to tar
var um = new Map();
um[0] = -1;
var left, right;
var cur = 0, maxi = -1;
for (i = 0; i < N; i++) {
cur += A[i];
if (um.has(cur - tar)
&& i - um.get(cur - tar) > maxi) {
maxi = i - um.get(cur - tar);
right = i;
left = um.get(cur - tar);
}
if (!um.has(cur))
um.set(cur,i);
}
// If there is no subarray with
// sum equal to tar
if (maxi == -1)
cout << -1;
else {
for (i = 0; i <= left; i++)
document.write(A[i]+' ');
for (i = 0; i < right; i++)
document.write(A[N - i - 1]+ ' ');
}
}
// Driver Code
var N = 7;
// Given Array
var A = [3, 2, 1, 1, 1, 1, 3];
// Given target sum
var K = 10;
minSizeArr(A, N, K);
</script>
Time Complexity: O(N)
Auxiliary Space: O(N)
Related Topic: Subarrays, Subsequences, and Subsets in Array
Similar Reads
Minimum removal of K equal elements required to empty an array
Given an array arr[] consisting of N integers, the task is to count the minimum number of times at most K equal elements are required to be removed to make the array empty. Examples: Input: arr[] = {1, 3, 1, 1, 3}, K = 2Output: 3Explanation: Step 1: Remove at most 2 1s from the array. The modified a
7 min read
Queries to find minimum sum of array elements from either end of an array
Given an array arr[] consisting of N distinct integers and an array queries[] consisting of Q queries, the task is for each query is to find queries[i] in the array and calculate the minimum of sum of array elements from the start and end of the array up to queries[i]. Examples: Input: arr[] = {2, 3
12 min read
Minimum operations required to make all the array elements equal
Given an array arr[] of n integer and an integer k. The task is to count the minimum number of times the given operation is required to make all the array elements equal. In a single operation, the kth element of the array is appended at the end of the array and the first element of the array gets d
6 min read
Remove minimum elements from ends of array so that sum decreases by at least K | O(N)
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[] =
7 min read
Minimum sum after subtracting multiples of k from the elements of the array
Given an integer K and an integer array, the task is to find the minimum possible sum of all the elements of the array after they are reduced by subtracting a multiple of K from each element (the result must be positive and every element of the array must be equal after this reduction). If the array
15 min read
Minimum array elements required to be subtracted from either end to reduce K to 0
Given an array arr[] consisting of N integers and an integer K, the task is to reduce K to 0 by removing an array element from either end of the array and subtracting it from K. If it is impossible to reduce K to 0, then print "-1". Otherwise, print the minimum number of such operations required. Ex
9 min read
Minimize the sum of MEX by removing all elements of array
Given an array of integers arr[] of size N. You can perform the following operation N times: Pick any index i, and remove arr[i] from the array and add MEX(arr[]) i.e., Minimum Excluded of the array arr[] to your total score. Your task is to minimize the total score. Examples: Input: N = 8, arr[] =
7 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
Minimum count of elements required to obtain the given Array by repeated mirror operations
Given an array arr[] consisting of N integers, the task is to find the array K[] of minimum possible length such that after performing multiple mirror operations on K[], the given array arr[] can be obtained. Mirror Operation: Appending all the array elements to the original array in reverse order.
7 min read
Find K that requires minimum increments or decrements of array elements to obtain a sequence of increasing powers of K
Given an array consisting of N integers, the task is to find the integer K which requires the minimum number of moves to convert the given array to a sequence of powers of K, i.e. {K0, K1, K2, ......., KN - 1}. In each move, increase or decrease an array element by one. Examples: Input: arr[] = {1,
7 min read