diff --git a/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/README.md b/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/README.md
index 744cd2e6fbaab..bb2932f430b2c 100644
--- a/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/README.md	
+++ b/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/README.md	
@@ -156,6 +156,24 @@ function minimumCost(s: string): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn minimum_cost(s: String) -> i64 {
+        let mut ans = 0;
+        let n = s.len();
+        let s = s.as_bytes();
+        for i in 1..n {
+            if s[i] != s[i - 1] {
+                ans += i.min(n - i);
+            }
+        }
+        ans as i64
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/README_EN.md b/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/README_EN.md
index 4fdc8b5d7b20c..39e07f3e335db 100644
--- a/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/README_EN.md	
+++ b/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/README_EN.md	
@@ -155,6 +155,24 @@ function minimumCost(s: string): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn minimum_cost(s: String) -> i64 {
+        let mut ans = 0;
+        let n = s.len();
+        let s = s.as_bytes();
+        for i in 1..n {
+            if s[i] != s[i - 1] {
+                ans += i.min(n - i);
+            }
+        }
+        ans as i64
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/Solution.rs b/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/Solution.rs
new file mode 100644
index 0000000000000..6899f03efe1a2
--- /dev/null
+++ b/solution/2700-2799/2712.Minimum Cost to Make All Characters Equal/Solution.rs	
@@ -0,0 +1,13 @@
+impl Solution {
+    pub fn minimum_cost(s: String) -> i64 {
+        let mut ans = 0;
+        let n = s.len();
+        let s = s.as_bytes();
+        for i in 1..n {
+            if s[i] != s[i - 1] {
+                ans += i.min(n - i);
+            }
+        }
+        ans as i64
+    }
+}
diff --git a/solution/2700-2799/2716.Minimize String Length/README.md b/solution/2700-2799/2716.Minimize String Length/README.md
index 86079bba90735..05254fb0682f3 100644
--- a/solution/2700-2799/2716.Minimize String Length/README.md	
+++ b/solution/2700-2799/2716.Minimize String Length/README.md	
@@ -72,7 +72,7 @@ tags:
 
 题目实际上可以转化为求字符串中不同字符的个数，因此，我们只需要统计字符串中不同字符的个数即可。
 
-时间复杂度 $O(n)$，空间复杂度 $O(C)$。其中 $n$ 是字符串的长度；而 $C$ 是字符集的大小，本题中字符集为小写英文字母，因此 $C=26$。
+时间复杂度 $O(n)$，其中 $n$ 是字符串 $\textit{s}$ 的长度。空间复杂度 $O(|\Sigma|)$，其中 $\Sigma$ 是字符集，这里是小写英文字母，因此 $|\Sigma|=26$。
 
 <!-- tabs:start -->
 
@@ -104,8 +104,7 @@ class Solution {
 class Solution {
 public:
     int minimizedStringLength(string s) {
-        unordered_set<char> ss(s.begin(), s.end());
-        return ss.size();
+        return unordered_set<char>(s.begin(), s.end()).size();
     }
 };
 ```
@@ -143,6 +142,16 @@ impl Solution {
 }
 ```
 
+#### C#
+
+```cs
+public class Solution {
+    public int MinimizedStringLength(string s) {
+        return new HashSet<char>(s).Count;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/2700-2799/2716.Minimize String Length/README_EN.md b/solution/2700-2799/2716.Minimize String Length/README_EN.md
index d3fd7ea4de41b..7cf23ab0fa6c1 100644
--- a/solution/2700-2799/2716.Minimize String Length/README_EN.md	
+++ b/solution/2700-2799/2716.Minimize String Length/README_EN.md	
@@ -100,9 +100,9 @@ tags:
 
 ### Solution 1: Hash Table
 
-The problem can actually be transformed into finding the number of different characters in the string. Therefore, we only need to count the number of different characters in the string.
+The problem can actually be transformed into finding the number of distinct characters in the string. Therefore, we only need to count the number of distinct characters in the string.
 
-The time complexity is $O(n)$, and the space complexity is $O(C)$. Here, $n$ is the length of the string, and $C$ is the size of the character set. In this problem, the character set is lowercase English letters, so $C=26$.
+The time complexity is $O(n)$, where $n$ is the length of the string $\textit{s}$. The space complexity is $O(|\Sigma|)$, where $\Sigma$ is the character set. In this case, it's lowercase English letters, so $|\Sigma|=26$.
 
 <!-- tabs:start -->
 
@@ -134,8 +134,7 @@ class Solution {
 class Solution {
 public:
     int minimizedStringLength(string s) {
-        unordered_set<char> ss(s.begin(), s.end());
-        return ss.size();
+        return unordered_set<char>(s.begin(), s.end()).size();
     }
 };
 ```
@@ -173,6 +172,16 @@ impl Solution {
 }
 ```
 
+#### C#
+
+```cs
+public class Solution {
+    public int MinimizedStringLength(string s) {
+        return new HashSet<char>(s).Count;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/2700-2799/2716.Minimize String Length/Solution.cpp b/solution/2700-2799/2716.Minimize String Length/Solution.cpp
index 4826683b74eff..23f78810d5f7a 100644
--- a/solution/2700-2799/2716.Minimize String Length/Solution.cpp	
+++ b/solution/2700-2799/2716.Minimize String Length/Solution.cpp	
@@ -1,7 +1,6 @@
 class Solution {
 public:
     int minimizedStringLength(string s) {
-        unordered_set<char> ss(s.begin(), s.end());
-        return ss.size();
+        return unordered_set<char>(s.begin(), s.end()).size();
     }
-};
\ No newline at end of file
+};
diff --git a/solution/2700-2799/2716.Minimize String Length/Solution.cs b/solution/2700-2799/2716.Minimize String Length/Solution.cs
new file mode 100644
index 0000000000000..8c3b7ebe8acdb
--- /dev/null
+++ b/solution/2700-2799/2716.Minimize String Length/Solution.cs	
@@ -0,0 +1,5 @@
+public class Solution {
+    public int MinimizedStringLength(string s) {
+        return new HashSet<char>(s).Count;
+    }
+}
diff --git a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/README.md b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/README.md
index 17abe43dc30a1..7388b8f90de61 100644
--- a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/README.md	
+++ b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/README.md	
@@ -41,7 +41,7 @@ tags:
 <strong>输入：</strong>nums = [1,10,3,4,19]
 <strong>输出：</strong>133
 <strong>解释：</strong>下标三元组 (1, 2, 4) 的值是 (nums[1] - nums[2]) * nums[4] = 133 。
-可以证明不存在值大于 133 的有序下标三元组。 
+可以证明不存在值大于 133 的有序下标三元组。
 </pre>
 
 <p><strong class="example">示例 3：</strong></p>
@@ -69,7 +69,11 @@ tags:
 
 ### 方法一：维护前缀最大值和最大差值
 
-我们可以用两个变量 $mx$ 和 $mx\_diff$ 分别维护前缀最大值和最大差值。遍历数组时，更新这两个变量，答案为所有 $mx\_diff \times nums[i]$ 的最大值。
+我们用两个变量 $\textit{mx}$ 和 $\textit{mxDiff}$ 分别维护前缀最大值和最大差值，用一个变量 $\textit{ans}$ 维护答案。初始时，这些变量都为 $0$。
+
+接下来，我们枚举数组的每个元素 $x$ 作为 $\textit{nums}[k]$，首先更新答案 $\textit{ans} = \max(\textit{ans}, \textit{mxDiff} \times x)$，然后我们更新最大差值 $\textit{mxDiff} = \max(\textit{mxDiff}, \textit{mx} - x)$，最后更新前缀最大值 $\textit{mx} = \max(\textit{mx}, x)$。
+
+枚举完所有元素后，返回答案 $\textit{ans}$。
 
 时间复杂度 $O(n)$，其中 $n$ 是数组长度。空间复杂度 $O(1)$。
 
@@ -81,10 +85,10 @@ tags:
 class Solution:
     def maximumTripletValue(self, nums: List[int]) -> int:
         ans = mx = mx_diff = 0
-        for num in nums:
-            ans = max(ans, mx_diff * num)
-            mx = max(mx, num)
-            mx_diff = max(mx_diff, mx - num)
+        for x in nums:
+            ans = max(ans, mx_diff * x)
+            mx_diff = max(mx_diff, mx - x)
+            mx = max(mx, x)
         return ans
 ```
 
@@ -93,14 +97,12 @@ class Solution:
 ```java
 class Solution {
     public long maximumTripletValue(int[] nums) {
-        long max, maxDiff, ans;
-        max = 0;
-        maxDiff = 0;
-        ans = 0;
-        for (int num : nums) {
-            ans = Math.max(ans, num * maxDiff);
-            max = Math.max(max, num);
-            maxDiff = Math.max(maxDiff, max - num);
+        long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = Math.max(ans, mxDiff * x);
+            mxDiff = Math.max(mxDiff, mx - x);
+            mx = Math.max(mx, x);
         }
         return ans;
     }
@@ -113,12 +115,12 @@ class Solution {
 class Solution {
 public:
     long long maximumTripletValue(vector<int>& nums) {
-        long long ans = 0;
-        int mx = 0, mx_diff = 0;
-        for (int num : nums) {
-            ans = max(ans, 1LL * mx_diff * num);
-            mx = max(mx, num);
-            mx_diff = max(mx_diff, mx - num);
+        long long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = max(ans, mxDiff * x);
+            mxDiff = max(mxDiff, 1LL * mx - x);
+            mx = max(mx, x);
         }
         return ans;
     }
@@ -129,11 +131,11 @@ public:
 
 ```go
 func maximumTripletValue(nums []int) int64 {
-	ans, mx, mx_diff := 0, 0, 0
-	for _, num := range nums {
-		ans = max(ans, mx_diff*num)
-		mx = max(mx, num)
-		mx_diff = max(mx_diff, mx-num)
+	ans, mx, mxDiff := 0, 0, 0
+	for _, x := range nums {
+		ans = max(ans, mxDiff*x)
+		mxDiff = max(mxDiff, mx-x)
+		mx = max(mx, x)
 	}
 	return int64(ans)
 }
@@ -143,16 +145,36 @@ func maximumTripletValue(nums []int) int64 {
 
 ```ts
 function maximumTripletValue(nums: number[]): number {
-    let [ans, mx, mx_diff] = [0, 0, 0];
-    for (const num of nums) {
-        ans = Math.max(ans, mx_diff * num);
-        mx = Math.max(mx, num);
-        mx_diff = Math.max(mx_diff, mx - num);
+    let [ans, mx, mxDiff] = [0, 0, 0];
+    for (const x of nums) {
+        ans = Math.max(ans, mxDiff * x);
+        mxDiff = Math.max(mxDiff, mx - x);
+        mx = Math.max(mx, x);
     }
     return ans;
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_triplet_value(nums: Vec<i32>) -> i64 {
+        let mut ans: i64 = 0;
+        let mut mx: i32 = 0;
+        let mut mx_diff: i32 = 0;
+
+        for &x in &nums {
+            ans = ans.max(mx_diff as i64 * x as i64);
+            mx_diff = mx_diff.max(mx - x);
+            mx = mx.max(x);
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/README_EN.md b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/README_EN.md
index 42059e472f811..33c09398f9fc5 100644
--- a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/README_EN.md	
+++ b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/README_EN.md	
@@ -31,7 +31,7 @@ tags:
 <strong>Input:</strong> nums = [12,6,1,2,7]
 <strong>Output:</strong> 77
 <strong>Explanation:</strong> The value of the triplet (0, 2, 4) is (nums[0] - nums[2]) * nums[4] = 77.
-It can be shown that there are no ordered triplets of indices with a value greater than 77. 
+It can be shown that there are no ordered triplets of indices with a value greater than 77.
 </pre>
 
 <p><strong class="example">Example 2:</strong></p>
@@ -65,9 +65,13 @@ It can be shown that there are no ordered triplets of indices with a value great
 
 <!-- solution:start -->
 
-### Solution 1: Maintain Maximum Prefix Value and Maximum Difference
+### Solution 1: Maintaining Prefix Maximum and Maximum Difference
 
-We can use two variables $mx$ and $mx\_diff$ to maintain the maximum prefix value and maximum difference, respectively. When traversing the array, we update these two variables, and the answer is the maximum value of all $mx\_diff \times nums[i]$.
+We use two variables $\textit{mx}$ and $\textit{mxDiff}$ to maintain the prefix maximum value and maximum difference, respectively, and use a variable $\textit{ans}$ to maintain the answer. Initially, these variables are all $0$.
+
+Next, we iterate through each element $x$ in the array as $\textit{nums}[k]$. First, we update the answer $\textit{ans} = \max(\textit{ans}, \textit{mxDiff} \times x)$. Then we update the maximum difference $\textit{mxDiff} = \max(\textit{mxDiff}, \textit{mx} - x)$. Finally, we update the prefix maximum value $\textit{mx} = \max(\textit{mx}, x)$.
+
+After iterating through all elements, we return the answer $\textit{ans}$.
 
 The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
 
@@ -79,10 +83,10 @@ The time complexity is $O(n)$, where $n$ is the length of the array. The space c
 class Solution:
     def maximumTripletValue(self, nums: List[int]) -> int:
         ans = mx = mx_diff = 0
-        for num in nums:
-            ans = max(ans, mx_diff * num)
-            mx = max(mx, num)
-            mx_diff = max(mx_diff, mx - num)
+        for x in nums:
+            ans = max(ans, mx_diff * x)
+            mx_diff = max(mx_diff, mx - x)
+            mx = max(mx, x)
         return ans
 ```
 
@@ -91,14 +95,12 @@ class Solution:
 ```java
 class Solution {
     public long maximumTripletValue(int[] nums) {
-        long max, maxDiff, ans;
-        max = 0;
-        maxDiff = 0;
-        ans = 0;
-        for (int num : nums) {
-            ans = Math.max(ans, num * maxDiff);
-            max = Math.max(max, num);
-            maxDiff = Math.max(maxDiff, max - num);
+        long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = Math.max(ans, mxDiff * x);
+            mxDiff = Math.max(mxDiff, mx - x);
+            mx = Math.max(mx, x);
         }
         return ans;
     }
@@ -111,12 +113,12 @@ class Solution {
 class Solution {
 public:
     long long maximumTripletValue(vector<int>& nums) {
-        long long ans = 0;
-        int mx = 0, mx_diff = 0;
-        for (int num : nums) {
-            ans = max(ans, 1LL * mx_diff * num);
-            mx = max(mx, num);
-            mx_diff = max(mx_diff, mx - num);
+        long long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = max(ans, mxDiff * x);
+            mxDiff = max(mxDiff, 1LL * mx - x);
+            mx = max(mx, x);
         }
         return ans;
     }
@@ -127,11 +129,11 @@ public:
 
 ```go
 func maximumTripletValue(nums []int) int64 {
-	ans, mx, mx_diff := 0, 0, 0
-	for _, num := range nums {
-		ans = max(ans, mx_diff*num)
-		mx = max(mx, num)
-		mx_diff = max(mx_diff, mx-num)
+	ans, mx, mxDiff := 0, 0, 0
+	for _, x := range nums {
+		ans = max(ans, mxDiff*x)
+		mxDiff = max(mxDiff, mx-x)
+		mx = max(mx, x)
 	}
 	return int64(ans)
 }
@@ -141,16 +143,36 @@ func maximumTripletValue(nums []int) int64 {
 
 ```ts
 function maximumTripletValue(nums: number[]): number {
-    let [ans, mx, mx_diff] = [0, 0, 0];
-    for (const num of nums) {
-        ans = Math.max(ans, mx_diff * num);
-        mx = Math.max(mx, num);
-        mx_diff = Math.max(mx_diff, mx - num);
+    let [ans, mx, mxDiff] = [0, 0, 0];
+    for (const x of nums) {
+        ans = Math.max(ans, mxDiff * x);
+        mxDiff = Math.max(mxDiff, mx - x);
+        mx = Math.max(mx, x);
     }
     return ans;
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_triplet_value(nums: Vec<i32>) -> i64 {
+        let mut ans: i64 = 0;
+        let mut mx: i32 = 0;
+        let mut mx_diff: i32 = 0;
+
+        for &x in &nums {
+            ans = ans.max(mx_diff as i64 * x as i64);
+            mx_diff = mx_diff.max(mx - x);
+            mx = mx.max(x);
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.cpp b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.cpp
index fa6cb8efa928e..a26f8ee375a6d 100644
--- a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.cpp	
+++ b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.cpp	
@@ -1,13 +1,13 @@
 class Solution {
 public:
     long long maximumTripletValue(vector<int>& nums) {
-        long long ans = 0;
-        int mx = 0, mx_diff = 0;
-        for (int num : nums) {
-            ans = max(ans, 1LL * mx_diff * num);
-            mx = max(mx, num);
-            mx_diff = max(mx_diff, mx - num);
+        long long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = max(ans, mxDiff * x);
+            mxDiff = max(mxDiff, 1LL * mx - x);
+            mx = max(mx, x);
         }
         return ans;
     }
-};
\ No newline at end of file
+};
diff --git a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.go b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.go
index b1f300b08467a..a7bc0db301cc0 100644
--- a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.go	
+++ b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.go	
@@ -1,9 +1,9 @@
 func maximumTripletValue(nums []int) int64 {
-	ans, mx, mx_diff := 0, 0, 0
-	for _, num := range nums {
-		ans = max(ans, mx_diff*num)
-		mx = max(mx, num)
-		mx_diff = max(mx_diff, mx-num)
+	ans, mx, mxDiff := 0, 0, 0
+	for _, x := range nums {
+		ans = max(ans, mxDiff*x)
+		mxDiff = max(mxDiff, mx-x)
+		mx = max(mx, x)
 	}
 	return int64(ans)
-}
\ No newline at end of file
+}
diff --git a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.java b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.java
index 2a020a1a66cca..f75a8dd4efb3e 100644
--- a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.java	
+++ b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.java	
@@ -1,14 +1,12 @@
 class Solution {
     public long maximumTripletValue(int[] nums) {
-        long max, maxDiff, ans;
-        max = 0;
-        maxDiff = 0;
-        ans = 0;
-        for (int num : nums) {
-            ans = Math.max(ans, num * maxDiff);
-            max = Math.max(max, num);
-            maxDiff = Math.max(maxDiff, max - num);
+        long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = Math.max(ans, mxDiff * x);
+            mxDiff = Math.max(mxDiff, mx - x);
+            mx = Math.max(mx, x);
         }
         return ans;
     }
-}
\ No newline at end of file
+}
diff --git a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.py b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.py
index a0b5b3e824a3a..4290207f24879 100644
--- a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.py	
+++ b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.py	
@@ -1,8 +1,8 @@
 class Solution:
     def maximumTripletValue(self, nums: List[int]) -> int:
         ans = mx = mx_diff = 0
-        for num in nums:
-            ans = max(ans, mx_diff * num)
-            mx = max(mx, num)
-            mx_diff = max(mx_diff, mx - num)
+        for x in nums:
+            ans = max(ans, mx_diff * x)
+            mx_diff = max(mx_diff, mx - x)
+            mx = max(mx, x)
         return ans
diff --git a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.rs b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.rs
new file mode 100644
index 0000000000000..cb7f14099f53f
--- /dev/null
+++ b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.rs	
@@ -0,0 +1,15 @@
+impl Solution {
+    pub fn maximum_triplet_value(nums: Vec<i32>) -> i64 {
+        let mut ans: i64 = 0;
+        let mut mx: i32 = 0;
+        let mut mx_diff: i32 = 0;
+
+        for &x in &nums {
+            ans = ans.max(mx_diff as i64 * x as i64);
+            mx_diff = mx_diff.max(mx - x);
+            mx = mx.max(x);
+        }
+
+        ans
+    }
+}
diff --git a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.ts b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.ts
index f70346b89e985..c1a3b5a088e84 100644
--- a/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.ts	
+++ b/solution/2800-2899/2873.Maximum Value of an Ordered Triplet I/Solution.ts	
@@ -1,9 +1,9 @@
 function maximumTripletValue(nums: number[]): number {
-    let [ans, mx, mx_diff] = [0, 0, 0];
-    for (const num of nums) {
-        ans = Math.max(ans, mx_diff * num);
-        mx = Math.max(mx, num);
-        mx_diff = Math.max(mx_diff, mx - num);
+    let [ans, mx, mxDiff] = [0, 0, 0];
+    for (const x of nums) {
+        ans = Math.max(ans, mxDiff * x);
+        mxDiff = Math.max(mxDiff, mx - x);
+        mx = Math.max(mx, x);
     }
     return ans;
 }
diff --git a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/README.md b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/README.md
index 55b6402ce953e..6f8732b67ac97 100644
--- a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/README.md	
+++ b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/README.md	
@@ -41,7 +41,7 @@ tags:
 <strong>输入：</strong>nums = [1,10,3,4,19]
 <strong>输出：</strong>133
 <strong>解释：</strong>下标三元组 (1, 2, 4) 的值是 (nums[1] - nums[2]) * nums[4] = 133 。
-可以证明不存在值大于 133 的有序下标三元组。 
+可以证明不存在值大于 133 的有序下标三元组。
 </pre>
 
 <p><strong class="example">示例 3：</strong></p>
@@ -69,7 +69,11 @@ tags:
 
 ### 方法一：维护前缀最大值和最大差值
 
-我们可以用两个变量 $mx$ 和 $mx\_diff$ 分别维护前缀最大值和最大差值。遍历数组时，更新这两个变量，答案为所有 $mx\_diff \times nums[i]$ 的最大值。
+我们用两个变量 $\textit{mx}$ 和 $\textit{mxDiff}$ 分别维护前缀最大值和最大差值，用一个变量 $\textit{ans}$ 维护答案。初始时，这些变量都为 $0$。
+
+接下来，我们枚举数组的每个元素 $x$ 作为 $\textit{nums}[k]$，首先更新答案 $\textit{ans} = \max(\textit{ans}, \textit{mxDiff} \times x)$，然后我们更新最大差值 $\textit{mxDiff} = \max(\textit{mxDiff}, \textit{mx} - x)$，最后更新前缀最大值 $\textit{mx} = \max(\textit{mx}, x)$。
+
+枚举完所有元素后，返回答案 $\textit{ans}$。
 
 时间复杂度 $O(n)$，其中 $n$ 是数组长度。空间复杂度 $O(1)$。
 
@@ -81,10 +85,10 @@ tags:
 class Solution:
     def maximumTripletValue(self, nums: List[int]) -> int:
         ans = mx = mx_diff = 0
-        for num in nums:
-            ans = max(ans, mx_diff * num)
-            mx = max(mx, num)
-            mx_diff = max(mx_diff, mx - num)
+        for x in nums:
+            ans = max(ans, mx_diff * x)
+            mx_diff = max(mx_diff, mx - x)
+            mx = max(mx, x)
         return ans
 ```
 
@@ -93,14 +97,12 @@ class Solution:
 ```java
 class Solution {
     public long maximumTripletValue(int[] nums) {
-        long max, maxDiff, ans;
-        max = 0;
-        maxDiff = 0;
-        ans = 0;
-        for (int num : nums) {
-            ans = Math.max(ans, num * maxDiff);
-            max = Math.max(max, num);
-            maxDiff = Math.max(maxDiff, max - num);
+        long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = Math.max(ans, mxDiff * x);
+            mxDiff = Math.max(mxDiff, mx - x);
+            mx = Math.max(mx, x);
         }
         return ans;
     }
@@ -113,12 +115,12 @@ class Solution {
 class Solution {
 public:
     long long maximumTripletValue(vector<int>& nums) {
-        long long ans = 0;
-        int mx = 0, mx_diff = 0;
-        for (int num : nums) {
-            ans = max(ans, 1LL * mx_diff * num);
-            mx = max(mx, num);
-            mx_diff = max(mx_diff, mx - num);
+        long long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = max(ans, mxDiff * x);
+            mxDiff = max(mxDiff, 1LL * mx - x);
+            mx = max(mx, x);
         }
         return ans;
     }
@@ -129,11 +131,11 @@ public:
 
 ```go
 func maximumTripletValue(nums []int) int64 {
-	ans, mx, mx_diff := 0, 0, 0
-	for _, num := range nums {
-		ans = max(ans, mx_diff*num)
-		mx = max(mx, num)
-		mx_diff = max(mx_diff, mx-num)
+	ans, mx, mxDiff := 0, 0, 0
+	for _, x := range nums {
+		ans = max(ans, mxDiff*x)
+		mxDiff = max(mxDiff, mx-x)
+		mx = max(mx, x)
 	}
 	return int64(ans)
 }
@@ -143,16 +145,36 @@ func maximumTripletValue(nums []int) int64 {
 
 ```ts
 function maximumTripletValue(nums: number[]): number {
-    let [ans, mx, mx_diff] = [0, 0, 0];
-    for (const num of nums) {
-        ans = Math.max(ans, mx_diff * num);
-        mx = Math.max(mx, num);
-        mx_diff = Math.max(mx_diff, mx - num);
+    let [ans, mx, mxDiff] = [0, 0, 0];
+    for (const x of nums) {
+        ans = Math.max(ans, mxDiff * x);
+        mxDiff = Math.max(mxDiff, mx - x);
+        mx = Math.max(mx, x);
     }
     return ans;
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_triplet_value(nums: Vec<i32>) -> i64 {
+        let mut ans: i64 = 0;
+        let mut mx: i32 = 0;
+        let mut mx_diff: i32 = 0;
+
+        for &x in &nums {
+            ans = ans.max(mx_diff as i64 * x as i64);
+            mx_diff = mx_diff.max(mx - x);
+            mx = mx.max(x);
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/README_EN.md b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/README_EN.md
index 6ca64b15433a0..24b82d12a4169 100644
--- a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/README_EN.md	
+++ b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/README_EN.md	
@@ -31,7 +31,7 @@ tags:
 <strong>Input:</strong> nums = [12,6,1,2,7]
 <strong>Output:</strong> 77
 <strong>Explanation:</strong> The value of the triplet (0, 2, 4) is (nums[0] - nums[2]) * nums[4] = 77.
-It can be shown that there are no ordered triplets of indices with a value greater than 77. 
+It can be shown that there are no ordered triplets of indices with a value greater than 77.
 </pre>
 
 <p><strong class="example">Example 2:</strong></p>
@@ -65,9 +65,13 @@ It can be shown that there are no ordered triplets of indices with a value great
 
 <!-- solution:start -->
 
-### Solution 1: Maintain Maximum Prefix Value and Maximum Difference
+### Solution 1: Maintaining Prefix Maximum and Maximum Difference
 
-We can use two variables $mx$ and $mx\_diff$ to maintain the maximum prefix value and maximum difference, respectively. When traversing the array, we update these two variables, and the answer is the maximum value of all $mx\_diff \times nums[i]$.
+We use two variables $\textit{mx}$ and $\textit{mxDiff}$ to maintain the prefix maximum value and maximum difference, respectively, and use a variable $\textit{ans}$ to maintain the answer. Initially, these variables are all $0$.
+
+Next, we iterate through each element $x$ in the array as $\textit{nums}[k]$. First, we update the answer $\textit{ans} = \max(\textit{ans}, \textit{mxDiff} \times x)$. Then we update the maximum difference $\textit{mxDiff} = \max(\textit{mxDiff}, \textit{mx} - x)$. Finally, we update the prefix maximum value $\textit{mx} = \max(\textit{mx}, x)$.
+
+After iterating through all elements, we return the answer $\textit{ans}$.
 
 The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
 
@@ -79,10 +83,10 @@ The time complexity is $O(n)$, where $n$ is the length of the array. The space c
 class Solution:
     def maximumTripletValue(self, nums: List[int]) -> int:
         ans = mx = mx_diff = 0
-        for num in nums:
-            ans = max(ans, mx_diff * num)
-            mx = max(mx, num)
-            mx_diff = max(mx_diff, mx - num)
+        for x in nums:
+            ans = max(ans, mx_diff * x)
+            mx_diff = max(mx_diff, mx - x)
+            mx = max(mx, x)
         return ans
 ```
 
@@ -91,14 +95,12 @@ class Solution:
 ```java
 class Solution {
     public long maximumTripletValue(int[] nums) {
-        long max, maxDiff, ans;
-        max = 0;
-        maxDiff = 0;
-        ans = 0;
-        for (int num : nums) {
-            ans = Math.max(ans, num * maxDiff);
-            max = Math.max(max, num);
-            maxDiff = Math.max(maxDiff, max - num);
+        long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = Math.max(ans, mxDiff * x);
+            mxDiff = Math.max(mxDiff, mx - x);
+            mx = Math.max(mx, x);
         }
         return ans;
     }
@@ -111,12 +113,12 @@ class Solution {
 class Solution {
 public:
     long long maximumTripletValue(vector<int>& nums) {
-        long long ans = 0;
-        int mx = 0, mx_diff = 0;
-        for (int num : nums) {
-            ans = max(ans, 1LL * mx_diff * num);
-            mx = max(mx, num);
-            mx_diff = max(mx_diff, mx - num);
+        long long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = max(ans, mxDiff * x);
+            mxDiff = max(mxDiff, 1LL * mx - x);
+            mx = max(mx, x);
         }
         return ans;
     }
@@ -127,11 +129,11 @@ public:
 
 ```go
 func maximumTripletValue(nums []int) int64 {
-	ans, mx, mx_diff := 0, 0, 0
-	for _, num := range nums {
-		ans = max(ans, mx_diff*num)
-		mx = max(mx, num)
-		mx_diff = max(mx_diff, mx-num)
+	ans, mx, mxDiff := 0, 0, 0
+	for _, x := range nums {
+		ans = max(ans, mxDiff*x)
+		mxDiff = max(mxDiff, mx-x)
+		mx = max(mx, x)
 	}
 	return int64(ans)
 }
@@ -141,16 +143,36 @@ func maximumTripletValue(nums []int) int64 {
 
 ```ts
 function maximumTripletValue(nums: number[]): number {
-    let [ans, mx, mx_diff] = [0, 0, 0];
-    for (const num of nums) {
-        ans = Math.max(ans, mx_diff * num);
-        mx = Math.max(mx, num);
-        mx_diff = Math.max(mx_diff, mx - num);
+    let [ans, mx, mxDiff] = [0, 0, 0];
+    for (const x of nums) {
+        ans = Math.max(ans, mxDiff * x);
+        mxDiff = Math.max(mxDiff, mx - x);
+        mx = Math.max(mx, x);
     }
     return ans;
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn maximum_triplet_value(nums: Vec<i32>) -> i64 {
+        let mut ans: i64 = 0;
+        let mut mx: i32 = 0;
+        let mut mx_diff: i32 = 0;
+
+        for &x in &nums {
+            ans = ans.max(mx_diff as i64 * x as i64);
+            mx_diff = mx_diff.max(mx - x);
+            mx = mx.max(x);
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->
diff --git a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.cpp b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.cpp
index fa6cb8efa928e..a26f8ee375a6d 100644
--- a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.cpp	
+++ b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.cpp	
@@ -1,13 +1,13 @@
 class Solution {
 public:
     long long maximumTripletValue(vector<int>& nums) {
-        long long ans = 0;
-        int mx = 0, mx_diff = 0;
-        for (int num : nums) {
-            ans = max(ans, 1LL * mx_diff * num);
-            mx = max(mx, num);
-            mx_diff = max(mx_diff, mx - num);
+        long long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = max(ans, mxDiff * x);
+            mxDiff = max(mxDiff, 1LL * mx - x);
+            mx = max(mx, x);
         }
         return ans;
     }
-};
\ No newline at end of file
+};
diff --git a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.go b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.go
index b1f300b08467a..a7bc0db301cc0 100644
--- a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.go	
+++ b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.go	
@@ -1,9 +1,9 @@
 func maximumTripletValue(nums []int) int64 {
-	ans, mx, mx_diff := 0, 0, 0
-	for _, num := range nums {
-		ans = max(ans, mx_diff*num)
-		mx = max(mx, num)
-		mx_diff = max(mx_diff, mx-num)
+	ans, mx, mxDiff := 0, 0, 0
+	for _, x := range nums {
+		ans = max(ans, mxDiff*x)
+		mxDiff = max(mxDiff, mx-x)
+		mx = max(mx, x)
 	}
 	return int64(ans)
-}
\ No newline at end of file
+}
diff --git a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.java b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.java
index 2a020a1a66cca..f75a8dd4efb3e 100644
--- a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.java	
+++ b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.java	
@@ -1,14 +1,12 @@
 class Solution {
     public long maximumTripletValue(int[] nums) {
-        long max, maxDiff, ans;
-        max = 0;
-        maxDiff = 0;
-        ans = 0;
-        for (int num : nums) {
-            ans = Math.max(ans, num * maxDiff);
-            max = Math.max(max, num);
-            maxDiff = Math.max(maxDiff, max - num);
+        long ans = 0, mxDiff = 0;
+        int mx = 0;
+        for (int x : nums) {
+            ans = Math.max(ans, mxDiff * x);
+            mxDiff = Math.max(mxDiff, mx - x);
+            mx = Math.max(mx, x);
         }
         return ans;
     }
-}
\ No newline at end of file
+}
diff --git a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.py b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.py
index a0b5b3e824a3a..4290207f24879 100644
--- a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.py	
+++ b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.py	
@@ -1,8 +1,8 @@
 class Solution:
     def maximumTripletValue(self, nums: List[int]) -> int:
         ans = mx = mx_diff = 0
-        for num in nums:
-            ans = max(ans, mx_diff * num)
-            mx = max(mx, num)
-            mx_diff = max(mx_diff, mx - num)
+        for x in nums:
+            ans = max(ans, mx_diff * x)
+            mx_diff = max(mx_diff, mx - x)
+            mx = max(mx, x)
         return ans
diff --git a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.rs b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.rs
new file mode 100644
index 0000000000000..cb7f14099f53f
--- /dev/null
+++ b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.rs	
@@ -0,0 +1,15 @@
+impl Solution {
+    pub fn maximum_triplet_value(nums: Vec<i32>) -> i64 {
+        let mut ans: i64 = 0;
+        let mut mx: i32 = 0;
+        let mut mx_diff: i32 = 0;
+
+        for &x in &nums {
+            ans = ans.max(mx_diff as i64 * x as i64);
+            mx_diff = mx_diff.max(mx - x);
+            mx = mx.max(x);
+        }
+
+        ans
+    }
+}
diff --git a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.ts b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.ts
index f70346b89e985..c1a3b5a088e84 100644
--- a/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.ts	
+++ b/solution/2800-2899/2874.Maximum Value of an Ordered Triplet II/Solution.ts	
@@ -1,9 +1,9 @@
 function maximumTripletValue(nums: number[]): number {
-    let [ans, mx, mx_diff] = [0, 0, 0];
-    for (const num of nums) {
-        ans = Math.max(ans, mx_diff * num);
-        mx = Math.max(mx, num);
-        mx_diff = Math.max(mx_diff, mx - num);
+    let [ans, mx, mxDiff] = [0, 0, 0];
+    for (const x of nums) {
+        ans = Math.max(ans, mxDiff * x);
+        mxDiff = Math.max(mxDiff, mx - x);
+        mx = Math.max(mx, x);
     }
     return ans;
 }