diff --git a/solution/2400-2499/2401.Longest Nice Subarray/README.md b/solution/2400-2499/2401.Longest Nice Subarray/README.md
index e867a761f5f2f..e10d432c80521 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/README.md	
+++ b/solution/2400-2499/2401.Longest Nice Subarray/README.md	
@@ -66,19 +66,15 @@ tags:
 
 ### 方法一：双指针
 
-我们定义一个变量 $mask$，用于记录当前子数组中的元素按位或的结果，初始时 $mask = 0$。另外，使用双指针 $j$ 和 $i$ 分别指向当前子数组的左右端点，初始时 $i = j = 0$。
+根据题目描述，子数组的每个元素的二进制位上的 $1$ 的位置不能相同，这样才能保证任意两个元素的按位与结果为 $0$。
 
-接下来，我们从左到右遍历数组 $nums$，对于遍历到的每个元素 $x$：
+因此，我们可以使用双指针 $l$ 和 $r$ 维护一个滑动窗口，使得窗口内的元素满足题目条件。
 
-我们将其与 $mask$ 按位与，如果结果不为 $0$，则说明 $x$ 和 $mask$ 中至少有一个元素的二进制表示中的某一位为 $1$，而另一个元素的二进制表示中的对应位为 $0$，这样的元素对不可能满足题目要求，因此我们需要将 $j$ 右移，直到 $x$ 和 $mask$ 按位与的结果为 $0$ 为止。
+我们用一个变量 $\textit{mask}$ 来表示窗口内的元素的按位或的结果，接下来，遍历数组的每个元素。对于当前元素 $x$，如果 $\textit{mask}$ 和 $x$ 的按位与结果不为 $0$，说明当前元素 $x$ 与窗口内的元素有重复的二进制位，此时需要移动左指针 $l$，直到 $\textit{mask}$ 和 $x$ 的按位与结果为 $0$。然后，我们将 $\textit{mask}$ 和 $x$ 的按位或的结果赋值给 $\textit{mask}$，并更新答案 $\textit{ans} = \max(\textit{ans}, r - l + 1)$。
 
-此时，我们就找到了一个满足题目要求的子数组，其长度为 $i - j + 1$，我们将其与当前的最长优雅子数组的长度进行比较，如果大于当前的最长优雅子数组的长度，则更新最长优雅子数组的长度。
+遍历结束后，返回答案 $\textit{ans}$ 即可。
 
-然后我们将 $mask$ 和 $x$ 按位或，继续遍历下一个元素。
-
-最终，我们得到的最长优雅子数组的长度即为答案。
-
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 $nums$ 的长度。
+时间复杂度 $O(n)$，其中 $n$ 为数组 $\textit{nums}$ 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -87,13 +83,13 @@ tags:
 ```python
 class Solution:
     def longestNiceSubarray(self, nums: List[int]) -> int:
-        ans = j = mask = 0
-        for i, x in enumerate(nums):
+        ans = mask = l = 0
+        for r, x in enumerate(nums):
             while mask & x:
-                mask ^= nums[j]
-                j += 1
-            ans = max(ans, i - j + 1)
+                mask ^= nums[l]
+                l += 1
             mask |= x
+            ans = max(ans, r - l + 1)
         return ans
 ```
 
@@ -103,12 +99,12 @@ class Solution:
 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++];
+        for (int l = 0, r = 0; r < nums.length; ++r) {
+            while ((mask & nums[r]) != 0) {
+                mask ^= nums[l++];
             }
-            ans = Math.max(ans, i - j + 1);
-            mask |= nums[i];
+            mask |= nums[r];
+            ans = Math.max(ans, r - l + 1);
         }
         return ans;
     }
@@ -122,12 +118,12 @@ class Solution {
 public:
     int longestNiceSubarray(vector<int>& nums) {
         int ans = 0, mask = 0;
-        for (int i = 0, j = 0; i < nums.size(); ++i) {
-            while (mask & nums[i]) {
-                mask ^= nums[j++];
+        for (int l = 0, r = 0; r < nums.size(); ++r) {
+            while (mask & nums[r]) {
+                mask ^= nums[l++];
             }
-            ans = max(ans, i - j + 1);
-            mask |= nums[i];
+            mask |= nums[r];
+            ans = max(ans, r - l + 1);
         }
         return ans;
     }
@@ -138,15 +134,14 @@ public:
 
 ```go
 func longestNiceSubarray(nums []int) (ans int) {
-	mask, j := 0, 0
-	for i, x := range nums {
-		for ; mask&x != 0; j++ {
-			mask ^= nums[j]
-		}
-		if k := i - j + 1; ans < k {
-			ans = k
+	mask, l := 0, 0
+	for r, x := range nums {
+		for mask&x != 0 {
+			mask ^= nums[l]
+			l++
 		}
 		mask |= x
+		ans = max(ans, r-l+1)
 	}
 	return
 }
@@ -156,14 +151,13 @@ func longestNiceSubarray(nums []int) (ans int) {
 
 ```ts
 function longestNiceSubarray(nums: number[]): number {
-    let mask = 0;
-    let ans = 0;
-    for (let i = 0, j = 0; i < nums.length; ++i) {
-        while ((mask & nums[i]) !== 0) {
-            mask ^= nums[j++];
+    let [ans, mask] = [0, 0];
+    for (let l = 0, r = 0; r < nums.length; ++r) {
+        while (mask & nums[r]) {
+            mask ^= nums[l++];
         }
-        ans = Math.max(ans, i - j + 1);
-        mask |= nums[i];
+        mask |= nums[r];
+        ans = Math.max(ans, r - l + 1);
     }
     return ans;
 }
@@ -176,19 +170,16 @@ 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;
+        let mut l = 0;
+        for (r, &x) in nums.iter().enumerate() {
+            while mask & x != 0 {
+                mask ^= nums[l];
+                l += 1;
             }
-            ans = ans.max(i - j + 1);
             mask |= x;
+            ans = ans.max((r - l + 1) as i32);
         }
-
-        ans as i32
+        ans
     }
 }
 ```
@@ -199,12 +190,12 @@ impl Solution {
 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++];
+        for (int l = 0, r = 0; r < nums.Length; ++r) {
+            while ((mask & nums[r]) != 0) {
+                mask ^= nums[l++];
             }
-            ans = Math.Max(ans, i - j + 1);
-            mask |= nums[i];
+            mask |= nums[r];
+            ans = Math.Max(ans, r - l + 1);
         }
         return ans;
     }
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 78a33fed5a1d4..df5184b28e1d5 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/README_EN.md	
+++ b/solution/2400-2499/2401.Longest Nice Subarray/README_EN.md	
@@ -66,19 +66,15 @@ It can be proven that no longer nice subarray can be obtained, so we return 3.</
 
 ### Solution 1: Two Pointers
 
-We define a variable $mask$ to record the bitwise OR result of the elements in the current subarray, initially $mask = 0$. Also, we use two pointers $j$ and $i$ to point to the left and right endpoints of the current subarray, initially $i = j = 0$.
+According to the problem description, the position of the binary $1$ in each element of the subarray must be unique to ensure that the bitwise AND result of any two elements is $0$.
 
-Next, we traverse the array $nums$ from left to right. For each element $x$ we encounter:
+Therefore, we can use two pointers, $l$ and $r$, to maintain a sliding window such that the elements within the window satisfy the problem's conditions.
 
-We perform a bitwise AND operation between it and $mask$. If the result is not $0$, it means that $x$ and at least one element in $mask$ have a binary representation where a certain bit is $1$, and the corresponding bit in the other element's binary representation is $0$. Such pairs of elements cannot satisfy the problem's requirements, so we need to move $j$ to the right until the bitwise AND result of $x$ and $mask$ is $0$.
+We use a variable $\textit{mask}$ to represent the bitwise OR result of the elements within the window. Next, we traverse each element of the array. For the current element $x$, if the bitwise AND result of $\textit{mask}$ and $x$ is not $0$, it means that the current element $x$ has overlapping binary bits with the elements in the window. At this point, we need to move the left pointer $l$ until the bitwise AND result of $\textit{mask}$ and $x$ is $0$. Then, we assign the bitwise OR result of $\textit{mask}$ and $x$ to $\textit{mask}$ and update the answer $\textit{ans} = \max(\textit{ans}, r - l + 1)$.
 
-At this point, we have found a subarray that satisfies the problem's requirements. Its length is $i - j + 1$. We compare it with the length of the current longest elegant subarray. If it is longer than the current longest elegant subarray, we update the length of the longest elegant subarray.
+After the traversal, return the answer $\textit{ans}$.
 
-Then we perform a bitwise OR operation between $mask$ and $x$, and continue to the next element.
-
-Finally, the length of the longest elegant subarray we obtain is the answer.
-
-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 $\textit{nums}$. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -87,13 +83,13 @@ The time complexity is $O(n)$, and the space complexity is $O(1)$. Here, $n$ is
 ```python
 class Solution:
     def longestNiceSubarray(self, nums: List[int]) -> int:
-        ans = j = mask = 0
-        for i, x in enumerate(nums):
+        ans = mask = l = 0
+        for r, x in enumerate(nums):
             while mask & x:
-                mask ^= nums[j]
-                j += 1
-            ans = max(ans, i - j + 1)
+                mask ^= nums[l]
+                l += 1
             mask |= x
+            ans = max(ans, r - l + 1)
         return ans
 ```
 
@@ -103,12 +99,12 @@ class Solution:
 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++];
+        for (int l = 0, r = 0; r < nums.length; ++r) {
+            while ((mask & nums[r]) != 0) {
+                mask ^= nums[l++];
             }
-            ans = Math.max(ans, i - j + 1);
-            mask |= nums[i];
+            mask |= nums[r];
+            ans = Math.max(ans, r - l + 1);
         }
         return ans;
     }
@@ -122,12 +118,12 @@ class Solution {
 public:
     int longestNiceSubarray(vector<int>& nums) {
         int ans = 0, mask = 0;
-        for (int i = 0, j = 0; i < nums.size(); ++i) {
-            while (mask & nums[i]) {
-                mask ^= nums[j++];
+        for (int l = 0, r = 0; r < nums.size(); ++r) {
+            while (mask & nums[r]) {
+                mask ^= nums[l++];
             }
-            ans = max(ans, i - j + 1);
-            mask |= nums[i];
+            mask |= nums[r];
+            ans = max(ans, r - l + 1);
         }
         return ans;
     }
@@ -138,15 +134,14 @@ public:
 
 ```go
 func longestNiceSubarray(nums []int) (ans int) {
-	mask, j := 0, 0
-	for i, x := range nums {
-		for ; mask&x != 0; j++ {
-			mask ^= nums[j]
-		}
-		if k := i - j + 1; ans < k {
-			ans = k
+	mask, l := 0, 0
+	for r, x := range nums {
+		for mask&x != 0 {
+			mask ^= nums[l]
+			l++
 		}
 		mask |= x
+		ans = max(ans, r-l+1)
 	}
 	return
 }
@@ -156,14 +151,13 @@ func longestNiceSubarray(nums []int) (ans int) {
 
 ```ts
 function longestNiceSubarray(nums: number[]): number {
-    let mask = 0;
-    let ans = 0;
-    for (let i = 0, j = 0; i < nums.length; ++i) {
-        while ((mask & nums[i]) !== 0) {
-            mask ^= nums[j++];
+    let [ans, mask] = [0, 0];
+    for (let l = 0, r = 0; r < nums.length; ++r) {
+        while (mask & nums[r]) {
+            mask ^= nums[l++];
         }
-        ans = Math.max(ans, i - j + 1);
-        mask |= nums[i];
+        mask |= nums[r];
+        ans = Math.max(ans, r - l + 1);
     }
     return ans;
 }
@@ -176,19 +170,16 @@ 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;
+        let mut l = 0;
+        for (r, &x) in nums.iter().enumerate() {
+            while mask & x != 0 {
+                mask ^= nums[l];
+                l += 1;
             }
-            ans = ans.max(i - j + 1);
             mask |= x;
+            ans = ans.max((r - l + 1) as i32);
         }
-
-        ans as i32
+        ans
     }
 }
 ```
@@ -199,12 +190,12 @@ impl Solution {
 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++];
+        for (int l = 0, r = 0; r < nums.Length; ++r) {
+            while ((mask & nums[r]) != 0) {
+                mask ^= nums[l++];
             }
-            ans = Math.Max(ans, i - j + 1);
-            mask |= nums[i];
+            mask |= nums[r];
+            ans = Math.Max(ans, r - l + 1);
         }
         return ans;
     }
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/Solution.cpp b/solution/2400-2499/2401.Longest Nice Subarray/Solution.cpp
index 71e34749d1a38..633b63e90db5d 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/Solution.cpp	
+++ b/solution/2400-2499/2401.Longest Nice Subarray/Solution.cpp	
@@ -2,13 +2,13 @@ class Solution {
 public:
     int longestNiceSubarray(vector<int>& nums) {
         int ans = 0, mask = 0;
-        for (int i = 0, j = 0; i < nums.size(); ++i) {
-            while (mask & nums[i]) {
-                mask ^= nums[j++];
+        for (int l = 0, r = 0; r < nums.size(); ++r) {
+            while (mask & nums[r]) {
+                mask ^= nums[l++];
             }
-            ans = max(ans, i - j + 1);
-            mask |= nums[i];
+            mask |= nums[r];
+            ans = max(ans, r - l + 1);
         }
         return ans;
     }
-};
\ No newline at end of file
+};
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/Solution.cs b/solution/2400-2499/2401.Longest Nice Subarray/Solution.cs
index cc3e51f577fd3..3b71a45bf0533 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/Solution.cs	
+++ b/solution/2400-2499/2401.Longest Nice Subarray/Solution.cs	
@@ -1,13 +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++];
+        for (int l = 0, r = 0; r < nums.Length; ++r) {
+            while ((mask & nums[r]) != 0) {
+                mask ^= nums[l++];
             }
-            ans = Math.Max(ans, i - j + 1);
-            mask |= nums[i];
+            mask |= nums[r];
+            ans = Math.Max(ans, r - l + 1);
         }
         return ans;
     }
-}
\ No newline at end of file
+}
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/Solution.go b/solution/2400-2499/2401.Longest Nice Subarray/Solution.go
index 4edf3ca720702..fe6ccd3d8feb5 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/Solution.go	
+++ b/solution/2400-2499/2401.Longest Nice Subarray/Solution.go	
@@ -1,13 +1,12 @@
 func longestNiceSubarray(nums []int) (ans int) {
-	mask, j := 0, 0
-	for i, x := range nums {
-		for ; mask&x != 0; j++ {
-			mask ^= nums[j]
-		}
-		if k := i - j + 1; ans < k {
-			ans = k
+	mask, l := 0, 0
+	for r, x := range nums {
+		for mask&x != 0 {
+			mask ^= nums[l]
+			l++
 		}
 		mask |= x
+		ans = max(ans, r-l+1)
 	}
 	return
-}
\ No newline at end of file
+}
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/Solution.java b/solution/2400-2499/2401.Longest Nice Subarray/Solution.java
index 3cc0f9bfa790f..b0ee08229ebd4 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/Solution.java	
+++ b/solution/2400-2499/2401.Longest Nice Subarray/Solution.java	
@@ -1,13 +1,13 @@
 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++];
+        for (int l = 0, r = 0; r < nums.length; ++r) {
+            while ((mask & nums[r]) != 0) {
+                mask ^= nums[l++];
             }
-            ans = Math.max(ans, i - j + 1);
-            mask |= nums[i];
+            mask |= nums[r];
+            ans = Math.max(ans, r - l + 1);
         }
         return ans;
     }
-}
\ No newline at end of file
+}
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/Solution.py b/solution/2400-2499/2401.Longest Nice Subarray/Solution.py
index d03ea3d77a171..baa1697413236 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/Solution.py	
+++ b/solution/2400-2499/2401.Longest Nice Subarray/Solution.py	
@@ -1,10 +1,10 @@
 class Solution:
     def longestNiceSubarray(self, nums: List[int]) -> int:
-        ans = j = mask = 0
-        for i, x in enumerate(nums):
+        ans = mask = l = 0
+        for r, x in enumerate(nums):
             while mask & x:
-                mask ^= nums[j]
-                j += 1
-            ans = max(ans, i - j + 1)
+                mask ^= nums[l]
+                l += 1
             mask |= x
+            ans = max(ans, r - l + 1)
         return ans
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/Solution.rs b/solution/2400-2499/2401.Longest Nice Subarray/Solution.rs
index 3f993606f8a90..9018f3430c515 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/Solution.rs	
+++ b/solution/2400-2499/2401.Longest Nice Subarray/Solution.rs	
@@ -2,18 +2,15 @@ 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;
+        let mut l = 0;
+        for (r, &x) in nums.iter().enumerate() {
+            while mask & x != 0 {
+                mask ^= nums[l];
+                l += 1;
             }
-            ans = ans.max(i - j + 1);
             mask |= x;
+            ans = ans.max((r - l + 1) as i32);
         }
-
-        ans as i32
+        ans
     }
 }
diff --git a/solution/2400-2499/2401.Longest Nice Subarray/Solution.ts b/solution/2400-2499/2401.Longest Nice Subarray/Solution.ts
index 5530c62078b36..9c0c92d75eaea 100644
--- a/solution/2400-2499/2401.Longest Nice Subarray/Solution.ts	
+++ b/solution/2400-2499/2401.Longest Nice Subarray/Solution.ts	
@@ -1,12 +1,11 @@
 function longestNiceSubarray(nums: number[]): number {
-    let mask = 0;
-    let ans = 0;
-    for (let i = 0, j = 0; i < nums.length; ++i) {
-        while ((mask & nums[i]) !== 0) {
-            mask ^= nums[j++];
+    let [ans, mask] = [0, 0];
+    for (let l = 0, r = 0; r < nums.length; ++r) {
+        while (mask & nums[r]) {
+            mask ^= nums[l++];
         }
-        ans = Math.max(ans, i - j + 1);
-        mask |= nums[i];
+        mask |= nums[r];
+        ans = Math.max(ans, r - l + 1);
     }
     return ans;
 }