Related Articles
Minimum number of array elements from either ends required to be subtracted from X to reduce X to 0
• Last Updated : 29 Apr, 2021

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

 `// C++ program to implement``// the above approach``#include ``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

 `// 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

 `# 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#

 `// 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.`

## Javascript

 ``
Output:
`2`

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. 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