Merge branch 'master' of github.com:BaffinLee/leetcode-javascript

Author: BaffinLee

1601-1700/1658. Minimum Operations to Reduce X to Zero.md

@@ -0,0 +1,87 @@
+# 1658. Minimum Operations to Reduce X to Zero
+
+- Difficulty: Medium.
+- Related Topics: Array, Hash Table, Binary Search, Sliding Window, Prefix Sum.
+- Similar Questions: Minimum Size Subarray Sum, Subarray Sum Equals K, Minimum Operations to Convert Number, Removing Minimum Number of Magic Beans, Minimum Operations to Make the Integer Zero.
+
+## Problem
+
+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
+
+```javascript
+/**
+ * @param {number[]} nums
+ * @param {number} x
+ * @return {number}
+ */
+var minOperations = function(nums, x) {
+    var leftSumMap = { 0: 0 };
+    var rightSumMap = { 0: 0 };
+    var leftSum = 0;
+    var rightSum = 0;
+    var min = Number.MAX_SAFE_INTEGER;
+    for (var i = 0; i < nums.length; i++) {
+      leftSum += nums[i];
+      rightSum += nums[nums.length - 1 - i];
+      leftSumMap[leftSum] = i + 1;
+      rightSumMap[rightSum] = i + 1;
+      if (rightSumMap[x - leftSum] !== undefined && (i + 1 + rightSumMap[x - leftSum]) <= nums.length) {
+        min = Math.min(min, i + 1 + rightSumMap[x - leftSum]);
+      }
+      if (leftSumMap[x - rightSum] !== undefined && (i + 1 + leftSumMap[x - rightSum]) <= nums.length) {
+        min = Math.min(min, i + 1 + leftSumMap[x - rightSum]);
+      }
+    }
+    return min === Number.MAX_SAFE_INTEGER ? -1 : min;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(n * n).