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++ program to implement // the above approach #include <bits/stdc++.h> using namespace std;
// Function to count the minimum // number of operations required // to reduce x to 0 static int minOperations( int nums[], int N,
int x)
{ // If sum of the array
// is less than x
int sum = 0;
for ( int i = 0; i < x; i++)
sum += nums[i];
if (sum < x)
return -1;
// Stores the count
// of operations
int ans = INT_MAX;
// Two pointers to traverse the array
int l = N - 1, r = N;
// Reduce x by the sum
// of the entire array
x -= sum;
// Iterate until l reaches
// the front of the array
while (l >= 0)
{
// If sum of elements from
// the front exceeds x
if (x <= 0)
{
// Shift towards left
x += nums[l];
l -= 1;
}
// If sum exceeds 0
if (x > 0)
{
// Reduce x by elements
// from the right
r -= 1;
x -= nums[r];
}
// If x is reduced to 0
if (x == 0)
{
// Update the minimum count
// of operations required
ans = min(ans,
(l + 1) + (N - r));
}
}
if (ans < INT_MAX)
return ans;
else
return -1;
} // Driver Code int main()
{ int nums[] = { 1, 1, 4, 2, 3 };
// Size of the array
int N = sizeof (nums) / sizeof (nums[0]);
int x = 5;
cout << minOperations(nums, N, x);
return 0;
} // This code is contributed by code_hunt |
// Java program to implement // the above approach import java.util.*;
class GFG
{ // Function to count the minimum
// number of operations required
// to reduce x to 0
static int minOperations( int nums[], int x)
{
// If sum of the array
// is less than x
int sum = 0 ;
for ( int i = 0 ; i < x; i++)
sum += nums[i];
if (sum < x)
return - 1 ;
// Stores the count
// of operations
int ans = Integer.MAX_VALUE;
// Two pointers to traverse the array
int l = nums.length - 1 , r = nums.length;
// Reduce x by the sum
// of the entire array
x -= sum;
// Iterate until l reaches
// the front of the array
while (l >= 0 ) {
// If sum of elements from
// the front exceeds x
if (x <= 0 ) {
// Shift towards left
x += nums[l];
l -= 1 ;
}
// If sum exceeds 0
if (x > 0 ) {
// Reduce x by elements
// from the right
r -= 1 ;
x -= nums[r];
}
// If x is reduced to 0
if (x == 0 ) {
// Update the minimum count
// of operations required
ans = Math.min(ans,
(l + 1 ) + (nums.length - r));
}
}
if (ans < Integer.MAX_VALUE)
return ans;
else
return - 1 ;
}
// Driver Code
public static void main(String[] args)
{
int [] nums = { 1 , 1 , 4 , 2 , 3 };
int x = 5 ;
System.out.println(minOperations(nums, x));
}
} // This code is contributed by shubhamsingh10 |
# Python3 Program to implement # the above approach import math
# Function to count the minimum # number of operations required # to reduce x to 0 def minOperations(nums, x):
# If sum of the array
# is less than x
if sum (nums) < x:
return - 1
# Stores the count
# of operations
ans = math.inf
# Two pointers to traverse the array
l, r = len (nums) - 1 , len (nums)
# Reduce x by the sum
# of the entire array
x - = sum (nums)
# Iterate until l reaches
# the front of the array
while l > = 0 :
# If sum of elements from
# the front exceeds x
if x < = 0 :
# Shift towards left
x + = nums[l]
l - = 1
# If sum exceeds 0
if x > 0 :
# Reduce x by elements
# from the right
r - = 1
x - = nums[r]
# If x is reduced to 0
if x = = 0 :
# Update the minimum count
# of operations required
ans = min (ans, (l + 1 ) + ( len (nums) - r))
return ans if ans < math.inf else - 1
# Driver Code nums = [ 1 , 1 , 4 , 2 , 3 ]
x = 5
print (minOperations(nums, x))
|
// C# Program to implement // the above approach using System;
class GFG {
// Function to count the minimum
// number of operations required
// to reduce x to 0
static int minOperations( int [] nums, int x)
{
// If sum of the array
// is less than x
int sum = 0;
for ( int i = 0; i < x; i++)
sum += nums[i];
if (sum < x)
return -1;
// Stores the count
// of operations
int ans = Int32.MaxValue;
// Two pointers to traverse the array
int l = nums.Length - 1, r = nums.Length;
// Reduce x by the sum
// of the entire array
x -= sum;
// Iterate until l reaches
// the front of the array
while (l >= 0) {
// If sum of elements from
// the front exceeds x
if (x <= 0) {
// Shift towards left
x += nums[l];
l -= 1;
}
// If sum exceeds 0
if (x > 0) {
// Reduce x by elements
// from the right
r -= 1;
x -= nums[r];
}
// If x is reduced to 0
if (x == 0) {
// Update the minimum count
// of operations required
ans = Math.Min(ans,
(l + 1) + (nums.Length - r));
}
}
if (ans < Int32.MaxValue)
return ans;
else
return -1;
}
// Driver Code
public static void Main()
{
int [] nums = { 1, 1, 4, 2, 3 };
int x = 5;
Console.Write(minOperations(nums, x));
}
} // This code is contributed by ukasp. |
<script> // Javascript program to implement // the above approach // Function to count the minimum // number of operations required // to reduce x to 0 function minOperations(nums, x)
{ // If sum of the array
// is less than x
let sum = 0;
for (let i = 0; i < x; i++)
sum += nums[i];
if (sum < x)
return -1;
// Stores the count
// of operations
let ans = Number.MAX_VALUE;
// Two pointers to traverse the array
let l = nums.length - 1, r = nums.length;
// Reduce x by the sum
// of the entire array
x -= sum;
// Iterate until l reaches
// the front of the array
while (l >= 0)
{
// If sum of elements from
// the front exceeds x
if (x <= 0)
{
// Shift towards left
x += nums[l];
l -= 1;
}
// If sum exceeds 0
if (x > 0)
{
// Reduce x by elements
// from the right
r -= 1;
x -= nums[r];
}
// If x is reduced to 0
if (x == 0)
{
// Update the minimum count
// of operations required
ans = Math.min(ans,
(l + 1) +
(nums.length - r));
}
}
if (ans < Number.MAX_VALUE)
return ans;
else
return -1;
} // Driver code let nums = [ 1, 1, 4, 2, 3 ]; let x = 5; document.write(minOperations(nums, x)); // This code is contributed by target_2 </script> |
// PHP program to implement <?php // Function to count the minimum number function minOperations( $nums , $N , $x ) {
// sum of the array
$sum = 0;
for ( $i = 0; $i < $x ; $i ++)
$sum += $nums [ $i ];
if ( $sum < $x )
return -1;
// Stores the count of operations
$ans = PHP_INT_MAX;
// Two pointers to traverse the array
$l = $N - 1;
$r = $N ;
// Reduce x by the sum
$x -= $sum ;
// Iterate until l reaches
while ( $l >= 0)
{
// sum of elements from
if ( $x <= 0)
{
// Shift towards left
$x += $nums [ $l ];
$l -= 1;
}
// If sum exceeds 0
if ( $x > 0)
{
$r -= 1;
$x -= $nums [ $r ];
}
// x is reduced to 0
if ( $x == 0)
{
// updating the minimum count
$ans = min( $ans , ( $l + 1) + ( $N - $r ));
}
}
if ( $ans < PHP_INT_MAX)
return $ans ;
else
return -1;
} // Driver Code $nums = array (1, 1, 4, 2, 3);
$N = count ( $nums );
$x = 5;
echo minOperations( $nums , $N , $x );
?> |
2
Time Complexity: O(N)
Auxiliary Space: O(1)