 Open in App
Not now

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

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
Related Articles