# Minimum number of array elements from either ends required to be subtracted from X to reduce X to 0

• Difficulty Level : Hard
• Last Updated : 17 Nov, 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:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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);``    ` `    ``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)

My Personal Notes arrow_drop_up