From 30cbc197abf56916b0933d8575464b2cbd1c3920 Mon Sep 17 00:00:00 2001
From: yanglbme <szuyanglb@outlook.com>
Date: Sat, 13 Apr 2024 10:46:33 +0800
Subject: [PATCH] feat: add solutions to lc problem: No.1658
No.1658.Minimum Operations to Reduce X to Zero
---
.../README.md | 312 +++++++++---------
.../README_EN.md | 312 +++++++++---------
.../Solution.c | 27 --
.../Solution.cpp | 37 +--
.../Solution.go | 41 ++-
.../Solution.java | 39 ++-
.../Solution.py | 26 +-
.../Solution.rs | 35 +-
.../Solution.ts | 22 +-
.../Solution2.cpp | 34 +-
.../Solution2.go | 41 ++-
.../Solution2.java | 38 +--
.../Solution2.py | 27 +-
.../Solution2.rs | 23 ++
.../Solution2.ts | 18 +-
.../2401.Longest Nice Subarray/README.md | 38 +++
.../2401.Longest Nice Subarray/README_EN.md | 38 +++
.../2401.Longest Nice Subarray/Solution.cs | 13 +
.../2401.Longest Nice Subarray/Solution.rs | 19 ++
19 files changed, 602 insertions(+), 538 deletions(-)
delete mode 100644 solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.c
create mode 100644 solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.rs
create mode 100644 solution/2400-2499/2401.Longest Nice Subarray/Solution.cs
create mode 100644 solution/2400-2499/2401.Longest Nice Subarray/Solution.rs
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/README.md b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/README.md
index fd83bf056b8a7..d36c1ce9da921 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/README.md
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/README.md
@@ -51,55 +51,52 @@
### 方法一：哈希表 + 前缀和
-我们可以将问题转换为求中间连续子数组的最大长度，使得子数组的和为 $x = sum(nums) - x$。
+根据题目描述，我们需要移除数组 $nums$ 左右两端的元素，使得移除的元素和等于 $x$，且移除的元素个数最少。我们可以将问题转化为：找到数组 $nums$ 中最长的连续子数组，使得子数组的和 $s = \sum_{i=0}^{n} nums[i] - x$。这样，我们就可以将问题转化为求解数组 $nums$ 中和为 $s$ 的最长连续子数组的长度 $mx$，答案即为 $n - mx$。
-定义一个哈希表 `vis`，其中 `vis[s]` 表示前缀和为 $s$ 的最小下标。
+我们初始化 $mx = -1$，然后使用哈希表 $vis$ 来存储前缀和，键为前缀和，值为前缀和对应的下标。
-遍历数组 `nums`，对于每个元素 $nums[i]$，我们先将 $nums[i]$ 加到前缀和 $s$ 上，如果哈希表中不存在 $s$，则将其加入哈希表，其值为当前下标 $i$。然后我们判断 $s - x$ 是否在哈希表中，如果存在，则说明存在一个下标 $j$，使得 $nums[j + 1,..i]$ 的和为 $x$，此时我们更新答案的最小值，即 $ans = min(ans, n - (i - j))$。
+遍历数组 $nums$，对于当前元素 $nums[i]$，计算前缀和 $t$，如果 $t$ 不在哈希表中，则将 $t$ 加入哈希表；如果 $t - s$ 在哈希表中，则更新 $mx = \max(mx, i - vis[t - s])$。
-遍历结束，如果找不到满足条件的子数组，返回 $-1$，否则返回 $ans$。
+最后，如果 $mx = -1$，则返回 $-1$，否则返回 $n - mx$。
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `nums` 的长度。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $nums$ 的长度。
<!-- tabs:start -->
```python
class Solution:
def minOperations(self, nums: List[int], x: int) -> int:
- x = sum(nums) - x
+ s = sum(nums) - x
vis = {0: -1}
- ans = inf
- s, n = 0, len(nums)
+ mx, t = -1, 0
for i, v in enumerate(nums):
- s += v
- if s not in vis:
- vis[s] = i
- if s - x in vis:
- j = vis[s - x]
- ans = min(ans, n - (i - j))
- return -1 if ans == inf else ans
+ t += v
+ if t not in vis:
+ vis[t] = i
+ if t - s in vis:
+ mx = max(mx, i - vis[t - s])
+ return -1 if mx == -1 else len(nums) - mx
```
```java
class Solution {
public int minOperations(int[] nums, int x) {
- x = -x;
+ int s = -x;
for (int v : nums) {
- x += v;
+ s += v;
}
Map<Integer, Integer> vis = new HashMap<>();
vis.put(0, -1);
+ int mx = -1, t = 0;
int n = nums.length;
- int ans = 1 << 30;
- for (int i = 0, s = 0; i < n; ++i) {
- s += nums[i];
- vis.putIfAbsent(s, i);
- if (vis.containsKey(s - x)) {
- int j = vis.get(s - x);
- ans = Math.min(ans, n - (i - j));
+ for (int i = 0; i < n; ++i) {
+ t += nums[i];
+ vis.putIfAbsent(t, i);
+ if (vis.containsKey(t - s)) {
+ mx = Math.max(mx, i - vis.get(t - s));
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return mx == -1 ? -1 : n - mx;
}
}
```
@@ -108,180 +105,146 @@ class Solution {
class Solution {
public:
int minOperations(vector<int>& nums, int x) {
- x = accumulate(nums.begin(), nums.end(), 0) - x;
- unordered_map<int, int> vis{{0, -1}};
+ int s = accumulate(nums.begin(), nums.end(), 0) - x;
+ unordered_map<int, int> vis = {{0, -1}};
+ int mx = -1, t = 0;
int n = nums.size();
- int ans = 1 << 30;
- for (int i = 0, s = 0; i < n; ++i) {
- s += nums[i];
- if (!vis.count(s)) {
- vis[s] = i;
+ for (int i = 0; i < n; ++i) {
+ t += nums[i];
+ if (!vis.contains(t)) {
+ vis[t] = i;
}
- if (vis.count(s - x)) {
- int j = vis[s - x];
- ans = min(ans, n - (i - j));
+ if (vis.contains(t - s)) {
+ mx = max(mx, i - vis[t - s]);
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return mx == -1 ? -1 : n - mx;
}
};
```
```go
func minOperations(nums []int, x int) int {
- x = -x
+ s := -x
for _, v := range nums {
- x += v
+ s += v
}
vis := map[int]int{0: -1}
- ans := 1 << 30
- s, n := 0, len(nums)
+ mx, t := -1, 0
for i, v := range nums {
- s += v
- if _, ok := vis[s]; !ok {
- vis[s] = i
+ t += v
+ if _, ok := vis[t]; !ok {
+ vis[t] = i
}
- if j, ok := vis[s-x]; ok {
- ans = min(ans, n-(i-j))
+ if j, ok := vis[t-s]; ok {
+ mx = max(mx, i-j)
}
}
- if ans == 1<<30 {
+ if mx == -1 {
return -1
}
- return ans
+ return len(nums) - mx
}
```
```ts
function minOperations(nums: number[], x: number): number {
- x = nums.reduce((a, b) => a + b, 0) - x;
- const vis = new Map();
- vis.set(0, -1);
+ const s = nums.reduce((acc, cur) => acc + cur, -x);
+ const vis: Map<number, number> = new Map([[0, -1]]);
+ let [mx, t] = [-1, 0];
const n = nums.length;
- let ans = 1 << 30;
- for (let i = 0, s = 0; i < n; ++i) {
- s += nums[i];
- if (!vis.has(s)) {
- vis.set(s, i);
+ for (let i = 0; i < n; ++i) {
+ t += nums[i];
+ if (!vis.has(t)) {
+ vis.set(t, i);
}
- if (vis.has(s - x)) {
- const j = vis.get(s - x);
- ans = Math.min(ans, n - (i - j));
+ if (vis.has(t - s)) {
+ mx = Math.max(mx, i - vis.get(t - s)!);
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return ~mx ? n - mx : -1;
}
```
```rust
+use std::collections::HashMap;
+
impl Solution {
pub fn min_operations(nums: Vec<i32>, x: i32) -> i32 {
- let n = nums.len();
- let target = nums.iter().sum::<i32>() - x;
- if target < 0 {
- return -1;
- }
- let mut ans = i32::MAX;
- let mut sum = 0;
- let mut i = 0;
- for j in 0..n {
- sum += nums[j];
- while sum > target {
- sum -= nums[i];
- i += 1;
+ let s = nums.iter().sum::<i32>() - x;
+ let mut vis: HashMap<i32, i32> = HashMap::new();
+ vis.insert(0, -1);
+ let mut mx = -1;
+ let mut t = 0;
+ for (i, v) in nums.iter().enumerate() {
+ t += v;
+ if !vis.contains_key(&t) {
+ vis.insert(t, i as i32);
}
- if sum == target {
- ans = ans.min((n - 1 - (j - i)) as i32);
+ if let Some(&j) = vis.get(&(t - s)) {
+ mx = mx.max((i as i32) - j);
}
}
- if ans == i32::MAX {
- return -1;
+ if mx == -1 {
+ -1
+ } else {
+ (nums.len() as i32) - mx
}
- ans
}
}
```
-```c
-#define min(a, b) (((a) < (b)) ? (a) : (b))
-
-int minOperations(int* nums, int numsSize, int x) {
- int target = -x;
- for (int i = 0; i < numsSize; i++) {
- target += nums[i];
- }
- if (target < 0) {
- return -1;
- }
- int ans = INT_MAX;
- int sum = 0;
- int i = 0;
- for (int j = 0; j < numsSize; j++) {
- sum += nums[j];
- while (sum > target) {
- sum -= nums[i++];
- }
- if (sum == target) {
- ans = min(ans, numsSize - 1 - (j - i));
- }
- }
- if (ans == INT_MAX) {
- return -1;
- }
- return ans;
-}
-```
-
<!-- tabs:end -->
### 方法二：双指针
-与方法一类似，我们要找到一个子数组，使得子数组的和为 $x = sum(nums) - x$。
+基于方法一的分析，我们需要求解数组 $nums$ 中和为 $s$ 的最长连续子数组的长度 $mx$。由于数组 $nums$ 中的元素都是正整数，数组的前缀和只会单调递增，因此我们可以使用双指针来求解。
+
+我们初始化指针 $j = 0$，前缀和 $t = 0$，最长连续子数组的长度 $mx = -1$。
-定义两个指针 $j$ 和 $i$，初始时 $i = j = 0$，然后我们向右移动指针 $i$，将 $nums[i]$ 加到前缀和 $s$ 上。如果 $s \gt x$，那么我们循环向右移动指针 $j$，并且将 $nums[j]$ 从前缀和 $s$ 上减去，直到 $s \le x$。如果 $s = x$，我们可以更新答案的最小值，即 $ans = min(ans, n - (i - j + 1))$。继续向右移动指针 $i$，重复上述过程。
+遍历数组 $nums$，对于当前元素 $nums[i]$，计算前缀和 $t += nums[i]$，如果 $t > s$，则移动指针 $j$，直到 $t \leq s$。如果 $t = s$，则更新 $mx = \max(mx, i - j + 1)$。
-最后，如果找不到满足条件的子数组，返回 $-1$，否则返回 $ans$。
+最后，如果 $mx = -1$，则返回 $-1$，否则返回 $n - mx$。
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `nums` 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为数组 $nums$ 的长度。空间复杂度 $O(1)$。
<!-- tabs:start -->
```python
class Solution:
def minOperations(self, nums: List[int], x: int) -> int:
- x = sum(nums) - x
- ans = inf
- n = len(nums)
- s = j = 0
- for i, v in enumerate(nums):
- s += v
- while j <= i and s > x:
- s -= nums[j]
+ s = sum(nums) - x
+ j = t = 0
+ mx = -1
+ for i, x in enumerate(nums):
+ t += x
+ while j <= i and t > s:
+ t -= nums[j]
j += 1
- if s == x:
- ans = min(ans, n - (i - j + 1))
- return -1 if ans == inf else ans
+ if t == s:
+ mx = max(mx, i - j + 1)
+ return -1 if mx == -1 else len(nums) - mx
```
```java
class Solution {
public int minOperations(int[] nums, int x) {
- x = -x;
+ int s = -x;
for (int v : nums) {
- x += v;
+ s += v;
}
+ int mx = -1, t = 0;
int n = nums.length;
- int ans = 1 << 30;
- for (int i = 0, j = 0, s = 0; i < n; ++i) {
- s += nums[i];
- while (j <= i && s > x) {
- s -= nums[j++];
+ for (int i = 0, j = 0; i < n; ++i) {
+ t += nums[i];
+ while (j <= i && t > s) {
+ t -= nums[j++];
}
- if (s == x) {
- ans = Math.min(ans, n - (i - j + 1));
+ if (t == s) {
+ mx = Math.max(mx, i - j + 1);
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return mx == -1 ? -1 : n - mx;
}
}
```
@@ -290,64 +253,87 @@ class Solution {
class Solution {
public:
int minOperations(vector<int>& nums, int x) {
- x = accumulate(nums.begin(), nums.end(), 0) - x;
+ int s = accumulate(nums.begin(), nums.end(), 0) - x;
+ int mx = -1, t = 0;
int n = nums.size();
- int ans = 1 << 30;
- for (int i = 0, j = 0, s = 0; i < n; ++i) {
- s += nums[i];
- while (j <= i && s > x) {
- s -= nums[j++];
+ for (int i = 0, j = 0; i < n; ++i) {
+ t += nums[i];
+ while (j <= i && t > s) {
+ t -= nums[j++];
}
- if (s == x) {
- ans = min(ans, n - (i - j + 1));
+ if (t == s) {
+ mx = max(mx, i - j + 1);
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return mx == -1 ? -1 : n - mx;
}
};
```
```go
func minOperations(nums []int, x int) int {
- x = -x
+ s := -x
for _, v := range nums {
- x += v
+ s += v
}
- ans := 1 << 30
- s, n := 0, len(nums)
- j := 0
+ mx, t, j := -1, 0, 0
for i, v := range nums {
- s += v
- for j <= i && s > x {
- s -= nums[j]
- j++
+ t += v
+ for ; j <= i && t > s; j++ {
+ t -= nums[j]
}
- if s == x {
- ans = min(ans, n-(i-j+1))
+ if t == s {
+ mx = max(mx, i-j+1)
}
}
- if ans == 1<<30 {
+ if mx == -1 {
return -1
}
- return ans
+ return len(nums) - mx
}
```
```ts
function minOperations(nums: number[], x: number): number {
- x = nums.reduce((a, b) => a + b, 0) - x;
+ const s = nums.reduce((acc, cur) => acc + cur, -x);
+ let [mx, t] = [-1, 0];
const n = nums.length;
- let ans = 1 << 30;
- for (let i = 0, j = 0, s = 0; i < n; ++i) {
- s += nums[i];
- while (j <= i && s > x) {
- s -= nums[j++];
+ for (let i = 0, j = 0; i < n; ++i) {
+ t += nums[i];
+ while (t > s) {
+ t -= nums[j++];
+ }
+ if (t === s) {
+ mx = Math.max(mx, i - j + 1);
+ }
+ }
+ return ~mx ? n - mx : -1;
+}
+```
+
+```rust
+impl Solution {
+ pub fn min_operations(nums: Vec<i32>, x: i32) -> i32 {
+ let s: i32 = nums.iter().sum::<i32>() - x;
+ let mut j: usize = 0;
+ let mut t: i32 = 0;
+ let mut mx: i32 = -1;
+ for (i, &v) in nums.iter().enumerate() {
+ t += v;
+ while j <= i && t > s {
+ t -= nums[j];
+ j += 1;
+ }
+ if t == s {
+ mx = mx.max((i - j + 1) as i32);
+ }
}
- if (s == x) {
- ans = Math.min(ans, n - (i - j + 1));
+ if mx == -1 {
+ -1
+ } else {
+ (nums.len() as i32) - mx
}
}
- return ans == 1 << 30 ? -1 : ans;
}
```
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/README_EN.md b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/README_EN.md
index 02322ac1014f6..8ad4d3e505410 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/README_EN.md
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/README_EN.md
@@ -47,55 +47,52 @@
### Solution 1: Hash Table + Prefix Sum
-We can transform the problem into finding the maximum length of a continuous subarray in the middle, such that the sum of the subarray is $x = sum(nums) - x$.
+According to the problem description, we need to remove elements from both ends of the array $nums$ so that the sum of the removed elements equals $x$, and the number of removed elements is minimized. We can transform the problem into: find the longest consecutive subarray in the array $nums$ such that the sum of the subarray $s = \sum_{i=0}^{n} nums[i] - x$. In this way, we can transform the problem into finding the length $mx$ of the longest consecutive subarray in the array $nums$ with a sum of $s$, and the answer is $n - mx$.
-Define a hash table `vis`, where `vis[s]` represents the smallest index with a prefix sum of $s$.
+We initialize $mx = -1$, and then use a hash table $vis$ to store the prefix sum, where the key is the prefix sum and the value is the index corresponding to the prefix sum.
-Traverse the array `nums`. For each element $nums[i]$, we first add $nums[i]$ to the prefix sum $s$. If $s$ does not exist in the hash table, we add it to the hash table, and its value is the current index $i$. Then we check whether $s - x$ exists in the hash table. If it does, it means that there exists an index $j$ such that the sum of $nums[j + 1,..i]$ is $x$. At this time, we update the minimum value of the answer, that is, $ans = min(ans, n - (i - j))$.
+Traverse the array $nums$, for the current element $nums[i]$, calculate the prefix sum $t$, if $t$ is not in the hash table, add $t$ to the hash table; if $t - s$ is in the hash table, update $mx = \max(mx, i - vis[t - s])$.
-At the end of the traversal, if no subarray meets the condition, return $-1$, otherwise return $ans$.
+Finally, if $mx = -1$, return $-1$, otherwise return $n - mx$.
-The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array `nums`.
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Where $n$ is the length of the array $nums$.
<!-- tabs:start -->
```python
class Solution:
def minOperations(self, nums: List[int], x: int) -> int:
- x = sum(nums) - x
+ s = sum(nums) - x
vis = {0: -1}
- ans = inf
- s, n = 0, len(nums)
+ mx, t = -1, 0
for i, v in enumerate(nums):
- s += v
- if s not in vis:
- vis[s] = i
- if s - x in vis:
- j = vis[s - x]
- ans = min(ans, n - (i - j))
- return -1 if ans == inf else ans
+ t += v
+ if t not in vis:
+ vis[t] = i
+ if t - s in vis:
+ mx = max(mx, i - vis[t - s])
+ return -1 if mx == -1 else len(nums) - mx
```
```java
class Solution {
public int minOperations(int[] nums, int x) {
- x = -x;
+ int s = -x;
for (int v : nums) {
- x += v;
+ s += v;
}
Map<Integer, Integer> vis = new HashMap<>();
vis.put(0, -1);
+ int mx = -1, t = 0;
int n = nums.length;
- int ans = 1 << 30;
- for (int i = 0, s = 0; i < n; ++i) {
- s += nums[i];
- vis.putIfAbsent(s, i);
- if (vis.containsKey(s - x)) {
- int j = vis.get(s - x);
- ans = Math.min(ans, n - (i - j));
+ for (int i = 0; i < n; ++i) {
+ t += nums[i];
+ vis.putIfAbsent(t, i);
+ if (vis.containsKey(t - s)) {
+ mx = Math.max(mx, i - vis.get(t - s));
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return mx == -1 ? -1 : n - mx;
}
}
```
@@ -104,180 +101,146 @@ class Solution {
class Solution {
public:
int minOperations(vector<int>& nums, int x) {
- x = accumulate(nums.begin(), nums.end(), 0) - x;
- unordered_map<int, int> vis{{0, -1}};
+ int s = accumulate(nums.begin(), nums.end(), 0) - x;
+ unordered_map<int, int> vis = {{0, -1}};
+ int mx = -1, t = 0;
int n = nums.size();
- int ans = 1 << 30;
- for (int i = 0, s = 0; i < n; ++i) {
- s += nums[i];
- if (!vis.count(s)) {
- vis[s] = i;
+ for (int i = 0; i < n; ++i) {
+ t += nums[i];
+ if (!vis.contains(t)) {
+ vis[t] = i;
}
- if (vis.count(s - x)) {
- int j = vis[s - x];
- ans = min(ans, n - (i - j));
+ if (vis.contains(t - s)) {
+ mx = max(mx, i - vis[t - s]);
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return mx == -1 ? -1 : n - mx;
}
};
```
```go
func minOperations(nums []int, x int) int {
- x = -x
+ s := -x
for _, v := range nums {
- x += v
+ s += v
}
vis := map[int]int{0: -1}
- ans := 1 << 30
- s, n := 0, len(nums)
+ mx, t := -1, 0
for i, v := range nums {
- s += v
- if _, ok := vis[s]; !ok {
- vis[s] = i
+ t += v
+ if _, ok := vis[t]; !ok {
+ vis[t] = i
}
- if j, ok := vis[s-x]; ok {
- ans = min(ans, n-(i-j))
+ if j, ok := vis[t-s]; ok {
+ mx = max(mx, i-j)
}
}
- if ans == 1<<30 {
+ if mx == -1 {
return -1
}
- return ans
+ return len(nums) - mx
}
```
```ts
function minOperations(nums: number[], x: number): number {
- x = nums.reduce((a, b) => a + b, 0) - x;
- const vis = new Map();
- vis.set(0, -1);
+ const s = nums.reduce((acc, cur) => acc + cur, -x);
+ const vis: Map<number, number> = new Map([[0, -1]]);
+ let [mx, t] = [-1, 0];
const n = nums.length;
- let ans = 1 << 30;
- for (let i = 0, s = 0; i < n; ++i) {
- s += nums[i];
- if (!vis.has(s)) {
- vis.set(s, i);
+ for (let i = 0; i < n; ++i) {
+ t += nums[i];
+ if (!vis.has(t)) {
+ vis.set(t, i);
}
- if (vis.has(s - x)) {
- const j = vis.get(s - x);
- ans = Math.min(ans, n - (i - j));
+ if (vis.has(t - s)) {
+ mx = Math.max(mx, i - vis.get(t - s)!);
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return ~mx ? n - mx : -1;
}
```
```rust
+use std::collections::HashMap;
+
impl Solution {
pub fn min_operations(nums: Vec<i32>, x: i32) -> i32 {
- let n = nums.len();
- let target = nums.iter().sum::<i32>() - x;
- if target < 0 {
- return -1;
- }
- let mut ans = i32::MAX;
- let mut sum = 0;
- let mut i = 0;
- for j in 0..n {
- sum += nums[j];
- while sum > target {
- sum -= nums[i];
- i += 1;
+ let s = nums.iter().sum::<i32>() - x;
+ let mut vis: HashMap<i32, i32> = HashMap::new();
+ vis.insert(0, -1);
+ let mut mx = -1;
+ let mut t = 0;
+ for (i, v) in nums.iter().enumerate() {
+ t += v;
+ if !vis.contains_key(&t) {
+ vis.insert(t, i as i32);
}
- if sum == target {
- ans = ans.min((n - 1 - (j - i)) as i32);
+ if let Some(&j) = vis.get(&(t - s)) {
+ mx = mx.max((i as i32) - j);
}
}
- if ans == i32::MAX {
- return -1;
+ if mx == -1 {
+ -1
+ } else {
+ (nums.len() as i32) - mx
}
- ans
}
}
```
-```c
-#define min(a, b) (((a) < (b)) ? (a) : (b))
-
-int minOperations(int* nums, int numsSize, int x) {
- int target = -x;
- for (int i = 0; i < numsSize; i++) {
- target += nums[i];
- }
- if (target < 0) {
- return -1;
- }
- int ans = INT_MAX;
- int sum = 0;
- int i = 0;
- for (int j = 0; j < numsSize; j++) {
- sum += nums[j];
- while (sum > target) {
- sum -= nums[i++];
- }
- if (sum == target) {
- ans = min(ans, numsSize - 1 - (j - i));
- }
- }
- if (ans == INT_MAX) {
- return -1;
- }
- return ans;
-}
-```
-
<!-- tabs:end -->
### Solution 2: Two Pointers
-Similar to Solution 1, we need to find a subarray such that the sum of the subarray is $x = sum(nums) - x$.
+Based on the analysis of Solution 1, we need to find the length $mx$ of the longest consecutive subarray in the array $nums$ with a sum of $s$. Since all elements in the array $nums$ are positive integers, the prefix sum of the array will only increase monotonically, so we can use two pointers to solve this problem.
+
+We initialize pointer $j = 0$, prefix sum $t = 0$, and the length of the longest consecutive subarray $mx = -1$.
-Define two pointers $j$ and $i$, initially $i = j = 0$. Then we move the pointer $i$ to the right, add $nums[i]$ to the prefix sum $s$. If $s > x$, then we move the pointer $j$ to the right in a loop, and subtract $nums[j]$ from the prefix sum $s$, until $s \le x$. If $s = x$, we can update the minimum value of the answer, that is, $ans = min(ans, n - (i - j + 1))$. Continue to move the pointer $i$ to the right, and repeat the above process.
+Traverse the array $nums$, for the current element $nums[i]$, calculate the prefix sum $t += nums[i]$. If $t > s$, then move the pointer $j$ until $t \leq s$. If $t = s$, then update $mx = \max(mx, i - j + 1)$.
-Finally, if no subarray meets the condition, return $-1$, otherwise return $ans$.
+Finally, if $mx = -1$, return $-1$, otherwise return $n - mx$.
-The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is the length of the array `nums`.
+The time complexity is $O(n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
<!-- tabs:start -->
```python
class Solution:
def minOperations(self, nums: List[int], x: int) -> int:
- x = sum(nums) - x
- ans = inf
- n = len(nums)
- s = j = 0
- for i, v in enumerate(nums):
- s += v
- while j <= i and s > x:
- s -= nums[j]
+ s = sum(nums) - x
+ j = t = 0
+ mx = -1
+ for i, x in enumerate(nums):
+ t += x
+ while j <= i and t > s:
+ t -= nums[j]
j += 1
- if s == x:
- ans = min(ans, n - (i - j + 1))
- return -1 if ans == inf else ans
+ if t == s:
+ mx = max(mx, i - j + 1)
+ return -1 if mx == -1 else len(nums) - mx
```
```java
class Solution {
public int minOperations(int[] nums, int x) {
- x = -x;
+ int s = -x;
for (int v : nums) {
- x += v;
+ s += v;
}
+ int mx = -1, t = 0;
int n = nums.length;
- int ans = 1 << 30;
- for (int i = 0, j = 0, s = 0; i < n; ++i) {
- s += nums[i];
- while (j <= i && s > x) {
- s -= nums[j++];
+ for (int i = 0, j = 0; i < n; ++i) {
+ t += nums[i];
+ while (j <= i && t > s) {
+ t -= nums[j++];
}
- if (s == x) {
- ans = Math.min(ans, n - (i - j + 1));
+ if (t == s) {
+ mx = Math.max(mx, i - j + 1);
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return mx == -1 ? -1 : n - mx;
}
}
```
@@ -286,64 +249,87 @@ class Solution {
class Solution {
public:
int minOperations(vector<int>& nums, int x) {
- x = accumulate(nums.begin(), nums.end(), 0) - x;
+ int s = accumulate(nums.begin(), nums.end(), 0) - x;
+ int mx = -1, t = 0;
int n = nums.size();
- int ans = 1 << 30;
- for (int i = 0, j = 0, s = 0; i < n; ++i) {
- s += nums[i];
- while (j <= i && s > x) {
- s -= nums[j++];
+ for (int i = 0, j = 0; i < n; ++i) {
+ t += nums[i];
+ while (j <= i && t > s) {
+ t -= nums[j++];
}
- if (s == x) {
- ans = min(ans, n - (i - j + 1));
+ if (t == s) {
+ mx = max(mx, i - j + 1);
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return mx == -1 ? -1 : n - mx;
}
};
```
```go
func minOperations(nums []int, x int) int {
- x = -x
+ s := -x
for _, v := range nums {
- x += v
+ s += v
}
- ans := 1 << 30
- s, n := 0, len(nums)
- j := 0
+ mx, t, j := -1, 0, 0
for i, v := range nums {
- s += v
- for j <= i && s > x {
- s -= nums[j]
- j++
+ t += v
+ for ; j <= i && t > s; j++ {
+ t -= nums[j]
}
- if s == x {
- ans = min(ans, n-(i-j+1))
+ if t == s {
+ mx = max(mx, i-j+1)
}
}
- if ans == 1<<30 {
+ if mx == -1 {
return -1
}
- return ans
+ return len(nums) - mx
}
```
```ts
function minOperations(nums: number[], x: number): number {
- x = nums.reduce((a, b) => a + b, 0) - x;
+ const s = nums.reduce((acc, cur) => acc + cur, -x);
+ let [mx, t] = [-1, 0];
const n = nums.length;
- let ans = 1 << 30;
- for (let i = 0, j = 0, s = 0; i < n; ++i) {
- s += nums[i];
- while (j <= i && s > x) {
- s -= nums[j++];
+ for (let i = 0, j = 0; i < n; ++i) {
+ t += nums[i];
+ while (t > s) {
+ t -= nums[j++];
+ }
+ if (t === s) {
+ mx = Math.max(mx, i - j + 1);
+ }
+ }
+ return ~mx ? n - mx : -1;
+}
+```
+
+```rust
+impl Solution {
+ pub fn min_operations(nums: Vec<i32>, x: i32) -> i32 {
+ let s: i32 = nums.iter().sum::<i32>() - x;
+ let mut j: usize = 0;
+ let mut t: i32 = 0;
+ let mut mx: i32 = -1;
+ for (i, &v) in nums.iter().enumerate() {
+ t += v;
+ while j <= i && t > s {
+ t -= nums[j];
+ j += 1;
+ }
+ if t == s {
+ mx = mx.max((i - j + 1) as i32);
+ }
}
- if (s == x) {
- ans = Math.min(ans, n - (i - j + 1));
+ if mx == -1 {
+ -1
+ } else {
+ (nums.len() as i32) - mx
}
}
- return ans == 1 << 30 ? -1 : ans;
}
```
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.c b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.c
deleted file mode 100644
index 386b6de7e2955..0000000000000
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.c
+++ /dev/null
@@ -1,27 +0,0 @@
-#define min(a, b) (((a) < (b)) ? (a) : (b))
-
-int minOperations(int* nums, int numsSize, int x) {
- int target = -x;
- for (int i = 0; i < numsSize; i++) {
- target += nums[i];
- }
- if (target < 0) {
- return -1;
- }
- int ans = INT_MAX;
- int sum = 0;
- int i = 0;
- for (int j = 0; j < numsSize; j++) {
- sum += nums[j];
- while (sum > target) {
- sum -= nums[i++];
- }
- if (sum == target) {
- ans = min(ans, numsSize - 1 - (j - i));
- }
- }
- if (ans == INT_MAX) {
- return -1;
- }
- return ans;
-}
\ No newline at end of file
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.cpp b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.cpp
index 62bf7d0114bdf..cb02c0d3199e0 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.cpp
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.cpp
@@ -1,20 +1,19 @@
-class Solution {
-public:
- int minOperations(vector<int>& nums, int x) {
- x = accumulate(nums.begin(), nums.end(), 0) - x;
- unordered_map<int, int> vis{{0, -1}};
- int n = nums.size();
- int ans = 1 << 30;
- for (int i = 0, s = 0; i < n; ++i) {
- s += nums[i];
- if (!vis.count(s)) {
- vis[s] = i;
- }
- if (vis.count(s - x)) {
- int j = vis[s - x];
- ans = min(ans, n - (i - j));
- }
- }
- return ans == 1 << 30 ? -1 : ans;
- }
+class Solution {
+public:
+ int minOperations(vector<int>& nums, int x) {
+ int s = accumulate(nums.begin(), nums.end(), 0) - x;
+ unordered_map<int, int> vis = {{0, -1}};
+ int mx = -1, t = 0;
+ int n = nums.size();
+ for (int i = 0; i < n; ++i) {
+ t += nums[i];
+ if (!vis.contains(t)) {
+ vis[t] = i;
+ }
+ if (vis.contains(t - s)) {
+ mx = max(mx, i - vis[t - s]);
+ }
+ }
+ return mx == -1 ? -1 : n - mx;
+ }
};
\ No newline at end of file
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.go b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.go
index df468c39f1462..847930dbf7dea 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.go
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.go
@@ -1,22 +1,21 @@
-func minOperations(nums []int, x int) int {
- x = -x
- for _, v := range nums {
- x += v
- }
- vis := map[int]int{0: -1}
- ans := 1 << 30
- s, n := 0, len(nums)
- for i, v := range nums {
- s += v
- if _, ok := vis[s]; !ok {
- vis[s] = i
- }
- if j, ok := vis[s-x]; ok {
- ans = min(ans, n-(i-j))
- }
- }
- if ans == 1<<30 {
- return -1
- }
- return ans
+func minOperations(nums []int, x int) int {
+ s := -x
+ for _, v := range nums {
+ s += v
+ }
+ vis := map[int]int{0: -1}
+ mx, t := -1, 0
+ for i, v := range nums {
+ t += v
+ if _, ok := vis[t]; !ok {
+ vis[t] = i
+ }
+ if j, ok := vis[t-s]; ok {
+ mx = max(mx, i-j)
+ }
+ }
+ if mx == -1 {
+ return -1
+ }
+ return len(nums) - mx
}
\ No newline at end of file
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.java b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.java
index 1fda2dcf11a25..e1f70f14d9f47 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.java
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.java
@@ -1,21 +1,20 @@
-class Solution {
- public int minOperations(int[] nums, int x) {
- x = -x;
- for (int v : nums) {
- x += v;
- }
- Map<Integer, Integer> vis = new HashMap<>();
- vis.put(0, -1);
- int n = nums.length;
- int ans = 1 << 30;
- for (int i = 0, s = 0; i < n; ++i) {
- s += nums[i];
- vis.putIfAbsent(s, i);
- if (vis.containsKey(s - x)) {
- int j = vis.get(s - x);
- ans = Math.min(ans, n - (i - j));
- }
- }
- return ans == 1 << 30 ? -1 : ans;
- }
+class Solution {
+ public int minOperations(int[] nums, int x) {
+ int s = -x;
+ for (int v : nums) {
+ s += v;
+ }
+ Map<Integer, Integer> vis = new HashMap<>();
+ vis.put(0, -1);
+ int mx = -1, t = 0;
+ int n = nums.length;
+ for (int i = 0; i < n; ++i) {
+ t += nums[i];
+ vis.putIfAbsent(t, i);
+ if (vis.containsKey(t - s)) {
+ mx = Math.max(mx, i - vis.get(t - s));
+ }
+ }
+ return mx == -1 ? -1 : n - mx;
+ }
}
\ No newline at end of file
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.py b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.py
index a124eb004a18f..22a0bddb50450 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.py
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.py
@@ -1,14 +1,12 @@
-class Solution:
- def minOperations(self, nums: List[int], x: int) -> int:
- x = sum(nums) - x
- vis = {0: -1}
- ans = inf
- s, n = 0, len(nums)
- for i, v in enumerate(nums):
- s += v
- if s not in vis:
- vis[s] = i
- if s - x in vis:
- j = vis[s - x]
- ans = min(ans, n - (i - j))
- return -1 if ans == inf else ans
+class Solution:
+ def minOperations(self, nums: List[int], x: int) -> int:
+ s = sum(nums) - x
+ vis = {0: -1}
+ mx, t = -1, 0
+ for i, v in enumerate(nums):
+ t += v
+ if t not in vis:
+ vis[t] = i
+ if t - s in vis:
+ mx = max(mx, i - vis[t - s])
+ return -1 if mx == -1 else len(nums) - mx
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.rs b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.rs
index b61d6c1af0b9d..8dd1e95030374 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.rs
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.rs
@@ -1,26 +1,25 @@
+use std::collections::HashMap;
+
impl Solution {
pub fn min_operations(nums: Vec<i32>, x: i32) -> i32 {
- let n = nums.len();
- let target = nums.iter().sum::<i32>() - x;
- if target < 0 {
- return -1;
- }
- let mut ans = i32::MAX;
- let mut sum = 0;
- let mut i = 0;
- for j in 0..n {
- sum += nums[j];
- while sum > target {
- sum -= nums[i];
- i += 1;
+ let s = nums.iter().sum::<i32>() - x;
+ let mut vis: HashMap<i32, i32> = HashMap::new();
+ vis.insert(0, -1);
+ let mut mx = -1;
+ let mut t = 0;
+ for (i, v) in nums.iter().enumerate() {
+ t += v;
+ if !vis.contains_key(&t) {
+ vis.insert(t, i as i32);
}
- if sum == target {
- ans = ans.min((n - 1 - (j - i)) as i32);
+ if let Some(&j) = vis.get(&(t - s)) {
+ mx = mx.max((i as i32) - j);
}
}
- if ans == i32::MAX {
- return -1;
+ if mx == -1 {
+ -1
+ } else {
+ (nums.len() as i32) - mx
}
- ans
}
}
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.ts b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.ts
index 42fd0c850ffb5..94f61a95ed74e 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.ts
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution.ts
@@ -1,18 +1,16 @@
function minOperations(nums: number[], x: number): number {
- x = nums.reduce((a, b) => a + b, 0) - x;
- const vis = new Map();
- vis.set(0, -1);
+ const s = nums.reduce((acc, cur) => acc + cur, -x);
+ const vis: Map<number, number> = new Map([[0, -1]]);
+ let [mx, t] = [-1, 0];
const n = nums.length;
- let ans = 1 << 30;
- for (let i = 0, s = 0; i < n; ++i) {
- s += nums[i];
- if (!vis.has(s)) {
- vis.set(s, i);
+ for (let i = 0; i < n; ++i) {
+ t += nums[i];
+ if (!vis.has(t)) {
+ vis.set(t, i);
}
- if (vis.has(s - x)) {
- const j = vis.get(s - x);
- ans = Math.min(ans, n - (i - j));
+ if (vis.has(t - s)) {
+ mx = Math.max(mx, i - vis.get(t - s)!);
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return ~mx ? n - mx : -1;
}
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.cpp b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.cpp
index 53511235a5b74..f082f1d0cd003 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.cpp
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.cpp
@@ -1,18 +1,18 @@
-class Solution {
-public:
- int minOperations(vector<int>& nums, int x) {
- x = accumulate(nums.begin(), nums.end(), 0) - x;
- int n = nums.size();
- int ans = 1 << 30;
- for (int i = 0, j = 0, s = 0; i < n; ++i) {
- s += nums[i];
- while (j <= i && s > x) {
- s -= nums[j++];
- }
- if (s == x) {
- ans = min(ans, n - (i - j + 1));
- }
- }
- return ans == 1 << 30 ? -1 : ans;
- }
+class Solution {
+public:
+ int minOperations(vector<int>& nums, int x) {
+ int s = accumulate(nums.begin(), nums.end(), 0) - x;
+ int mx = -1, t = 0;
+ int n = nums.size();
+ for (int i = 0, j = 0; i < n; ++i) {
+ t += nums[i];
+ while (j <= i && t > s) {
+ t -= nums[j++];
+ }
+ if (t == s) {
+ mx = max(mx, i - j + 1);
+ }
+ }
+ return mx == -1 ? -1 : n - mx;
+ }
};
\ No newline at end of file
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.go b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.go
index e900da722c758..3e937ee615df5 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.go
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.go
@@ -1,23 +1,20 @@
-func minOperations(nums []int, x int) int {
- x = -x
- for _, v := range nums {
- x += v
- }
- ans := 1 << 30
- s, n := 0, len(nums)
- j := 0
- for i, v := range nums {
- s += v
- for j <= i && s > x {
- s -= nums[j]
- j++
- }
- if s == x {
- ans = min(ans, n-(i-j+1))
- }
- }
- if ans == 1<<30 {
- return -1
- }
- return ans
+func minOperations(nums []int, x int) int {
+ s := -x
+ for _, v := range nums {
+ s += v
+ }
+ mx, t, j := -1, 0, 0
+ for i, v := range nums {
+ t += v
+ for ; j <= i && t > s; j++ {
+ t -= nums[j]
+ }
+ if t == s {
+ mx = max(mx, i-j+1)
+ }
+ }
+ if mx == -1 {
+ return -1
+ }
+ return len(nums) - mx
}
\ No newline at end of file
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.java b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.java
index 15902f37cef3e..4f3a39acfd2d1 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.java
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.java
@@ -1,20 +1,20 @@
-class Solution {
- public int minOperations(int[] nums, int x) {
- x = -x;
- for (int v : nums) {
- x += v;
- }
- int n = nums.length;
- int ans = 1 << 30;
- for (int i = 0, j = 0, s = 0; i < n; ++i) {
- s += nums[i];
- while (j <= i && s > x) {
- s -= nums[j++];
- }
- if (s == x) {
- ans = Math.min(ans, n - (i - j + 1));
- }
- }
- return ans == 1 << 30 ? -1 : ans;
- }
+class Solution {
+ public int minOperations(int[] nums, int x) {
+ int s = -x;
+ for (int v : nums) {
+ s += v;
+ }
+ int mx = -1, t = 0;
+ int n = nums.length;
+ for (int i = 0, j = 0; i < n; ++i) {
+ t += nums[i];
+ while (j <= i && t > s) {
+ t -= nums[j++];
+ }
+ if (t == s) {
+ mx = Math.max(mx, i - j + 1);
+ }
+ }
+ return mx == -1 ? -1 : n - mx;
+ }
}
\ No newline at end of file
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.py b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.py
index 38e18fc805418..ce772e9115043 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.py
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.py
@@ -1,14 +1,13 @@
-class Solution:
- def minOperations(self, nums: List[int], x: int) -> int:
- x = sum(nums) - x
- ans = inf
- n = len(nums)
- s = j = 0
- for i, v in enumerate(nums):
- s += v
- while j <= i and s > x:
- s -= nums[j]
- j += 1
- if s == x:
- ans = min(ans, n - (i - j + 1))
- return -1 if ans == inf else ans
+class Solution:
+ def minOperations(self, nums: List[int], x: int) -> int:
+ s = sum(nums) - x
+ j = t = 0
+ mx = -1
+ for i, x in enumerate(nums):
+ t += x
+ while j <= i and t > s:
+ t -= nums[j]
+ j += 1
+ if t == s:
+ mx = max(mx, i - j + 1)
+ return -1 if mx == -1 else len(nums) - mx
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.rs b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.rs
new file mode 100644
index 0000000000000..33be558a92a24
--- /dev/null
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.rs
@@ -0,0 +1,23 @@
+impl Solution {
+ pub fn min_operations(nums: Vec<i32>, x: i32) -> i32 {
+ let s: i32 = nums.iter().sum::<i32>() - x;
+ let mut j: usize = 0;
+ let mut t: i32 = 0;
+ let mut mx: i32 = -1;
+ for (i, &v) in nums.iter().enumerate() {
+ t += v;
+ while j <= i && t > s {
+ t -= nums[j];
+ j += 1;
+ }
+ if t == s {
+ mx = mx.max((i - j + 1) as i32);
+ }
+ }
+ if mx == -1 {
+ -1
+ } else {
+ (nums.len() as i32) - mx
+ }
+ }
+}
diff --git a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.ts b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.ts
index 8dfb6bc212caf..e4de9c271d037 100644
--- a/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.ts
+++ b/solution/1600-1699/1658.Minimum Operations to Reduce X to Zero/Solution2.ts
@@ -1,15 +1,15 @@
function minOperations(nums: number[], x: number): number {
- x = nums.reduce((a, b) => a + b, 0) - x;
+ const s = nums.reduce((acc, cur) => acc + cur, -x);
+ let [mx, t] = [-1, 0];
const n = nums.length;
- let ans = 1 << 30;
- for (let i = 0, j = 0, s = 0; i < n; ++i) {
- s += nums[i];
- while (j <= i && s > x) {
- s -= nums[j++];
+ for (let i = 0, j = 0; i < n; ++i) {
+ t += nums[i];
+ while (t > s) {
+ t -= nums[j++];
}
- if (s == x) {
- ans = Math.min(ans, n - (i - j + 1));
+ if (t === s) {
+ mx = Math.max(mx, i - j + 1);
}
}
- return ans == 1 << 30 ? -1 : ans;
+ return ~mx ? n - mx : -1;
}
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/README.md b/solution/2400-2499/2401.Longest Nice Subarray/README.md
index 52ff0ed745de0..66dd523736d8c 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/README.md
+++ b/solution/2400-2499/2401.Longest Nice Subarray/README.md
@@ -143,6 +143,44 @@ function longestNiceSubarray(nums: number[]): number {
}
```
+```rust
+impl Solution {
+ pub fn longest_nice_subarray(nums: Vec<i32>) -> i32 {
+ let mut ans = 0;
+ let mut mask = 0;
+ let mut j = 0;
+
+ for (i, &x) in nums.iter().enumerate() {
+ let mut x = x;
+ while (mask & x) != 0 {
+ mask ^= nums[j];
+ j += 1;
+ }
+ ans = ans.max(i - j + 1);
+ mask |= x;
+ }
+
+ ans as i32
+ }
+}
+```
+
+```cs
+public class Solution {
+ public int LongestNiceSubarray(int[] nums) {
+ int ans = 0, mask = 0;
+ for (int i = 0, j = 0; i < nums.Length; ++i) {
+ while ((mask & nums[i]) != 0) {
+ mask ^= nums[j++];
+ }
+ ans = Math.Max(ans, i - j + 1);
+ mask |= nums[i];
+ }
+ return ans;
+ }
+}
+```
+
<!-- tabs:end -->
<!-- end -->
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/README_EN.md b/solution/2400-2499/2401.Longest Nice Subarray/README_EN.md
index be4a238db9add..905fec762e044 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/README_EN.md
+++ b/solution/2400-2499/2401.Longest Nice Subarray/README_EN.md
@@ -141,6 +141,44 @@ function longestNiceSubarray(nums: number[]): number {
}
```
+```rust
+impl Solution {
+ pub fn longest_nice_subarray(nums: Vec<i32>) -> i32 {
+ let mut ans = 0;
+ let mut mask = 0;
+ let mut j = 0;
+
+ for (i, &x) in nums.iter().enumerate() {
+ let mut x = x;
+ while (mask & x) != 0 {
+ mask ^= nums[j];
+ j += 1;
+ }
+ ans = ans.max(i - j + 1);
+ mask |= x;
+ }
+
+ ans as i32
+ }
+}
+```
+
+```cs
+public class Solution {
+ public int LongestNiceSubarray(int[] nums) {
+ int ans = 0, mask = 0;
+ for (int i = 0, j = 0; i < nums.Length; ++i) {
+ while ((mask & nums[i]) != 0) {
+ mask ^= nums[j++];
+ }
+ ans = Math.Max(ans, i - j + 1);
+ mask |= nums[i];
+ }
+ return ans;
+ }
+}
+```
+
<!-- tabs:end -->
<!-- end -->
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/Solution.cs b/solution/2400-2499/2401.Longest Nice Subarray/Solution.cs
new file mode 100644
index 0000000000000..cc3e51f577fd3
--- /dev/null
+++ b/solution/2400-2499/2401.Longest Nice Subarray/Solution.cs
@@ -0,0 +1,13 @@
+public class Solution {
+ public int LongestNiceSubarray(int[] nums) {
+ int ans = 0, mask = 0;
+ for (int i = 0, j = 0; i < nums.Length; ++i) {
+ while ((mask & nums[i]) != 0) {
+ mask ^= nums[j++];
+ }
+ ans = Math.Max(ans, i - j + 1);
+ mask |= nums[i];
+ }
+ return ans;
+ }
+}
\ No newline at end of file
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/Solution.rs b/solution/2400-2499/2401.Longest Nice Subarray/Solution.rs
new file mode 100644
index 0000000000000..3f993606f8a90
--- /dev/null
+++ b/solution/2400-2499/2401.Longest Nice Subarray/Solution.rs
@@ -0,0 +1,19 @@
+impl Solution {
+ pub fn longest_nice_subarray(nums: Vec<i32>) -> i32 {
+ let mut ans = 0;
+ let mut mask = 0;
+ let mut j = 0;
+
+ for (i, &x) in nums.iter().enumerate() {
+ let mut x = x;
+ while (mask & x) != 0 {
+ mask ^= nums[j];
+ j += 1;
+ }
+ ans = ans.max(i - j + 1);
+ mask |= x;
+ }
+
+ ans as i32
+ }
+}