Minimum number of array elements from either ends required to be subtracted from X to reduce X to 0
Last Updated :
06 Apr, 2023
Given an array nums[] and an integer X, the task is to reduce X to 0 by removing either the leftmost or the rightmost array elements and subtracting its value from X, minimum number of times. If it’s possible to reduce X to 0, print the count of operations required. Otherwise, return -1.
Examples:
Input: nums[] = {3,2,20,1,1,3}, X = 10
Output: 5
Explanation: X (= 10) – 3 – 1 – 1 – 3 – 2 = 0. Therefore, the number of operations required is 5.
Input: nums[] = {1, 1, 4, 2, 3}, X = 5
Output: 2
Explanation: X (= 5) – 3 – 2 = 0. Therefore, the number of operations required is 2.
Approach: The given problem can be solved using Two Pointers technique. Follow the steps below to solve the problem.
- Maintain two pointers left and right, pointing to the ends of the left and right subarrays excluded from X.
- Initialize left to consider the entire array, and right to include nothing.
- Therefore, reduce X by the sum of the array.
- Now, iterate until left reaches the front of the array.
- If the sum of the left and the right subarrays exceeds X (i.e. X < 0), shift left by an index to the left and increase X that element.
- If the sum of the left and the right subarrays is less than X (i.e. X > 0), shift right pointer by an index to the left and reduce X by that element.
- If X is found to be 0 at any point, update the minimum number of operations required.
- Print the minimum number of operations required.
- Below is the implementation of the above approach:
C++14
#include <bits/stdc++.h>
using namespace std;
static int minOperations( int nums[], int N,
int x)
{
int sum = 0;
for ( int i = 0; i < x; i++)
sum += nums[i];
if (sum < x)
return -1;
int ans = INT_MAX;
int l = N - 1, r = N;
x -= sum;
while (l >= 0)
{
if (x <= 0)
{
x += nums[l];
l -= 1;
}
if (x > 0)
{
r -= 1;
x -= nums[r];
}
if (x == 0)
{
ans = min(ans,
(l + 1) + (N - r));
}
}
if (ans < INT_MAX)
return ans;
else
return -1;
}
int main()
{
int nums[] = { 1, 1, 4, 2, 3 };
int N = sizeof (nums) / sizeof (nums[0]);
int x = 5;
cout << minOperations(nums, N, x);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static int minOperations( int nums[], int x)
{
int sum = 0 ;
for ( int i = 0 ; i < x; i++)
sum += nums[i];
if (sum < x)
return - 1 ;
int ans = Integer.MAX_VALUE;
int l = nums.length - 1 , r = nums.length;
x -= sum;
while (l >= 0 ) {
if (x <= 0 ) {
x += nums[l];
l -= 1 ;
}
if (x > 0 ) {
r -= 1 ;
x -= nums[r];
}
if (x == 0 ) {
ans = Math.min(ans,
(l + 1 ) + (nums.length - r));
}
}
if (ans < Integer.MAX_VALUE)
return ans;
else
return - 1 ;
}
public static void main(String[] args)
{
int [] nums = { 1 , 1 , 4 , 2 , 3 };
int x = 5 ;
System.out.println(minOperations(nums, x));
}
}
|
Python3
import math
def minOperations(nums, x):
if sum (nums) < x:
return - 1
ans = math.inf
l, r = len (nums) - 1 , len (nums)
x - = sum (nums)
while l > = 0 :
if x < = 0 :
x + = nums[l]
l - = 1
if x > 0 :
r - = 1
x - = nums[r]
if x = = 0 :
ans = min (ans, (l + 1 ) + ( len (nums) - r))
return ans if ans < math.inf else - 1
nums = [ 1 , 1 , 4 , 2 , 3 ]
x = 5
print (minOperations(nums, x))
|
C#
using System;
class GFG {
static int minOperations( int [] nums, int x)
{
int sum = 0;
for ( int i = 0; i < x; i++)
sum += nums[i];
if (sum < x)
return -1;
int ans = Int32.MaxValue;
int l = nums.Length - 1, r = nums.Length;
x -= sum;
while (l >= 0) {
if (x <= 0) {
x += nums[l];
l -= 1;
}
if (x > 0) {
r -= 1;
x -= nums[r];
}
if (x == 0) {
ans = Math.Min(ans,
(l + 1) + (nums.Length - r));
}
}
if (ans < Int32.MaxValue)
return ans;
else
return -1;
}
public static void Main()
{
int [] nums = { 1, 1, 4, 2, 3 };
int x = 5;
Console.Write(minOperations(nums, x));
}
}
|
Javascript
<script>
function minOperations(nums, x)
{
let sum = 0;
for (let i = 0; i < x; i++)
sum += nums[i];
if (sum < x)
return -1;
let ans = Number.MAX_VALUE;
let l = nums.length - 1, r = nums.length;
x -= sum;
while (l >= 0)
{
if (x <= 0)
{
x += nums[l];
l -= 1;
}
if (x > 0)
{
r -= 1;
x -= nums[r];
}
if (x == 0)
{
ans = Math.min(ans,
(l + 1) +
(nums.length - r));
}
}
if (ans < Number.MAX_VALUE)
return ans;
else
return -1;
}
let nums = [ 1, 1, 4, 2, 3 ];
let x = 5;
document.write(minOperations(nums, x));
</script>
|
PHP
<?php
function minOperations( $nums , $N , $x ) {
$sum = 0;
for ( $i = 0; $i < $x ; $i ++)
$sum += $nums [ $i ];
if ( $sum < $x )
return -1;
$ans = PHP_INT_MAX;
$l = $N - 1;
$r = $N ;
$x -= $sum ;
while ( $l >= 0)
{
if ( $x <= 0)
{
$x += $nums [ $l ];
$l -= 1;
}
if ( $x > 0)
{
$r -= 1;
$x -= $nums [ $r ];
}
if ( $x == 0)
{
$ans = min( $ans , ( $l + 1) + ( $N - $r ));
}
}
if ( $ans < PHP_INT_MAX)
return $ans ;
else
return -1;
}
$nums = array (1, 1, 4, 2, 3);
$N = count ( $nums );
$x = 5;
echo minOperations( $nums , $N , $x );
?>
|
Time Complexity: O(N)
Auxiliary Space: O(1)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...