# 1658. Minimum Operations to Reduce X to Zero

#### Medium

***

You are given an integer array `nums` and an integer `x`. In one operation, you can either remove the leftmost or the rightmost element from the array `nums` and subtract its value from `x`. Note that this **modifies** the array for future operations.

Return *the **minimum number** of operations to reduce* `x` *to **exactly*** `0` *if it is possible, otherwise, return* `-1`.

 

**Example 1:**

```
Input: nums = [1,1,4,2,3], x = 5
Output: 2
Explanation: The optimal solution is to remove the last two elements to reduce x to zero.
```

**Example 2:**

```
Input: nums = [5,6,7,8,9], x = 4
Output: -1
```

**Example 3:**

```
Input: nums = [3,2,20,1,1,3], x = 10
Output: 5
Explanation: The optimal solution is to remove the last three elements and the first two elements (5 operations in total) to reduce x to zero.
```

 

**Constraints:**

* `1 <= nums.length <= 105`
* `1 <= nums[i] <= 104`
* `1 <= x <= 109`

#### Solution : This problem is using the same logic as PB 209

```python
class Solution:
    def minOperations(self, nums: List[int], x: int) -> int:
        return self.minSubArrayLen(nums, sum(nums) - x)
    
    # Smiply using the solution of PB 209
    def minSubArrayLen(self, nums, x):
        index, start, size, total = 0, 0, 0, 0
        found = False
        # Now we will try to get max subarray with matches to the target, because remaining numbers
        # will be the numbers that make x to 0
        while index < len(nums):
            total += nums[index]
            while total > x and start <= index:
                total -= nums[start]
                start += 1
            if total == x:
                found = True
                size = max(size, index-start+1)
            index += 1
        return -1 if not found else len(nums) - size
```