feat: add solutions for lc No.3634 (#5013)

Author: yanglbme

solution/3300-3399/3379.Transformed Array/README.md

@@ -82,7 +82,12 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：模拟
+
+我们创建一个结果数组 $\textit{ans}$，对于每个下标，根据 $nums[i]$ 的正负向右或向左移动 $|nums[i]|$ 步，计算出落脚的下标，并将该下标对应的值赋给 $\textit{ans}[i]$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组 $nums$ 的长度。
+
 
 <!-- tabs:start -->
 
@@ -91,11 +96,8 @@ tags:
 ```python
 class Solution:
     def constructTransformedArray(self, nums: List[int]) -> List[int]:
-        ans = []
         n = len(nums)
-        for i, x in enumerate(nums):
-            ans.append(nums[(i + x + n) % n] if x else 0)
-        return ans
+        return [nums[(i + x % n + n) % n] for i, x in enumerate(nums)]
 ```
 
 #### Java
@@ -106,7 +108,7 @@ class Solution {
         int n = nums.length;
         int[] ans = new int[n];
         for (int i = 0; i < n; ++i) {
-            ans[i] = nums[i] != 0 ? nums[(i + nums[i] % n + n) % n] : 0;
+            ans[i] = nums[(i + nums[i] % n + n) % n];
         }
         return ans;
     }
@@ -122,7 +124,7 @@ public:
         int n = nums.size();
         vector<int> ans(n);
         for (int i = 0; i < n; ++i) {
-            ans[i] = nums[i] ? nums[(i + nums[i] % n + n) % n] : 0;
+            ans[i] = nums[(i + nums[i] % n + n) % n];
         }
         return ans;
     }
@@ -136,9 +138,7 @@ func constructTransformedArray(nums []int) []int {
 	n := len(nums)
 	ans := make([]int, n)
 	for i, x := range nums {
-		if x != 0 {
-			ans[i] = nums[(i+x%n+n)%n]
-		}
+		ans[i] = nums[(i+x%n+n)%n]
 	}
 	return ans
 }
@@ -151,12 +151,27 @@ function constructTransformedArray(nums: number[]): number[] {
     const n = nums.length;
     const ans: number[] = [];
     for (let i = 0; i < n; ++i) {
-        ans.push(nums[i] ? nums[(i + (nums[i] % n) + n) % n] : 0);
+        ans.push(nums[(i + (nums[i] % n) + n) % n]);
     }
     return ans;
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn construct_transformed_array(nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len() as i32;
+        let mut ans = vec![0; nums.len()];
+        for (i, &x) in nums.iter().enumerate() {
+            ans[i] = nums[(((i as i32 + x % n + n) % n) as usize)];
+        }
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3300-3399/3379.Transformed Array/README_EN.md

@@ -80,7 +80,11 @@ For each index <code>i</code> (where <code>0 &lt;= i &lt; nums.length</code>), p
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Simulation
+
+We create a result array $\textit{ans}$. For each index, we move right or left $|nums[i]|$ steps based on whether $nums[i]$ is positive or negative, calculate the landing index, and assign the value at that index to $\textit{ans}[i]$.
+
+The time complexity is $O(n)$ and the space complexity is $O(n)$, where $n$ is the length of the array $nums$.
 
 <!-- tabs:start -->
 
@@ -89,11 +93,8 @@ For each index <code>i</code> (where <code>0 &lt;= i &lt; nums.length</code>), p
 ```python
 class Solution:
     def constructTransformedArray(self, nums: List[int]) -> List[int]:
-        ans = []
         n = len(nums)
-        for i, x in enumerate(nums):
-            ans.append(nums[(i + x + n) % n] if x else 0)
-        return ans
+        return [nums[(i + x % n + n) % n] for i, x in enumerate(nums)]
 ```
 
 #### Java
@@ -104,7 +105,7 @@ class Solution {
         int n = nums.length;
         int[] ans = new int[n];
         for (int i = 0; i < n; ++i) {
-            ans[i] = nums[i] != 0 ? nums[(i + nums[i] % n + n) % n] : 0;
+            ans[i] = nums[(i + nums[i] % n + n) % n];
         }
         return ans;
     }
@@ -120,7 +121,7 @@ public:
         int n = nums.size();
         vector<int> ans(n);
         for (int i = 0; i < n; ++i) {
-            ans[i] = nums[i] ? nums[(i + nums[i] % n + n) % n] : 0;
+            ans[i] = nums[(i + nums[i] % n + n) % n];
         }
         return ans;
     }
@@ -134,9 +135,7 @@ func constructTransformedArray(nums []int) []int {
 	n := len(nums)
 	ans := make([]int, n)
 	for i, x := range nums {
-		if x != 0 {
-			ans[i] = nums[(i+x%n+n)%n]
-		}
+		ans[i] = nums[(i+x%n+n)%n]
 	}
 	return ans
 }
@@ -149,12 +148,27 @@ function constructTransformedArray(nums: number[]): number[] {
     const n = nums.length;
     const ans: number[] = [];
     for (let i = 0; i < n; ++i) {
-        ans.push(nums[i] ? nums[(i + (nums[i] % n) + n) % n] : 0);
+        ans.push(nums[(i + (nums[i] % n) + n) % n]);
     }
     return ans;
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn construct_transformed_array(nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len() as i32;
+        let mut ans = vec![0; nums.len()];
+        for (i, &x) in nums.iter().enumerate() {
+            ans[i] = nums[(((i as i32 + x % n + n) % n) as usize)];
+        }
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3300-3399/3379.Transformed Array/Solution.cpp

@@ -4,7 +4,7 @@ class Solution {
         int n = nums.size();
         vector<int> ans(n);
         for (int i = 0; i < n; ++i) {
-            ans[i] = nums[i] ? nums[(i + nums[i] % n + n) % n] : 0;
+            ans[i] = nums[(i + nums[i] % n + n) % n];
         }
         return ans;
     }

solution/3300-3399/3379.Transformed Array/Solution.go

@@ -2,9 +2,7 @@ func constructTransformedArray(nums []int) []int {
 	n := len(nums)
 	ans := make([]int, n)
 	for i, x := range nums {
-		if x != 0 {
-			ans[i] = nums[(i+x%n+n)%n]
-		}
+		ans[i] = nums[(i+x%n+n)%n]
 	}
 	return ans
 }

solution/3300-3399/3379.Transformed Array/Solution.java

@@ -3,7 +3,7 @@ public int[] constructTransformedArray(int[] nums) {
         int n = nums.length;
         int[] ans = new int[n];
         for (int i = 0; i < n; ++i) {
-            ans[i] = nums[i] != 0 ? nums[(i + nums[i] % n + n) % n] : 0;
+            ans[i] = nums[(i + nums[i] % n + n) % n];
         }
         return ans;
     }

solution/3300-3399/3379.Transformed Array/Solution.py

@@ -1,7 +1,4 @@
 class Solution:
     def constructTransformedArray(self, nums: List[int]) -> List[int]:
-        ans = []
         n = len(nums)
-        for i, x in enumerate(nums):
-            ans.append(nums[(i + x + n) % n] if x else 0)
-        return ans
+        return [nums[(i + x % n + n) % n] for i, x in enumerate(nums)]

solution/3300-3399/3379.Transformed Array/Solution.rs

@@ -0,0 +1,10 @@
+impl Solution {
+    pub fn construct_transformed_array(nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len() as i32;
+        let mut ans = vec![0; nums.len()];
+        for (i, &x) in nums.iter().enumerate() {
+            ans[i] = nums[(((i as i32 + x % n + n) % n) as usize)];
+        }
+        ans
+    }
+}

solution/3300-3399/3379.Transformed Array/Solution.ts

@@ -2,7 +2,7 @@ function constructTransformedArray(nums: number[]): number[] {
     const n = nums.length;
     const ans: number[] = [];
     for (let i = 0; i < n; ++i) {
-        ans.push(nums[i] ? nums[(i + (nums[i] % n) + n) % n] : 0);
+        ans.push(nums[(i + (nums[i] % n) + n) % n]);
     }
     return ans;
 }

solution/3600-3699/3634.Minimum Removals to Balance Array/README.md

@@ -199,4 +199,92 @@ function minRemoval(nums: number[], k: number): number {
 
 <!-- solution:end -->
 
+<!-- solution:start -->
+
+### 方法二：排序 + 双指针
+
+我们首先对数组进行排序，然后我们使用双指针来维护一个滑动窗口，左指针 $l$ 从左到右枚举每个元素 $\textit{nums}[l]$ 作为平衡数组的最小值，右指针 $r$ 不断向右移动，直到 $\textit{nums}[r]$ 大于 $\textit{nums}[l] \times k$，此时平衡数组的长度为 $r - l$，需要移除的元素数量为 $n - (r - l)$，我们记录下最小的移除数量作为答案。
+
+时间复杂度 $O(n \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 是数组 $\textit{nums}$ 的长度。
+
+<!-- tabs:start -->
+
+#### Python3
+
+```python
+class Solution:
+    def minRemoval(self, nums: List[int], k: int) -> int:
+        nums.sort()
+        ans = n = len(nums)
+        r = 0
+        for l in range(n):
+            while r < n and nums[r] <= nums[l] * k:
+                r += 1
+            ans = min(ans, n - (r - l))
+        return ans
+```
+
+#### Java
+
+```java
+class Solution {
+    public int minRemoval(int[] nums, int k) {
+        Arrays.sort(nums);
+        int n = nums.length;
+        int ans = n;
+        int r = 0;
+        for (int l = 0; l < n; l++) {
+            while (r < n && nums[r] <= (long) nums[l] * k) {
+                r++;
+            }
+            ans = Math.min(ans, n - (r - l));
+        }
+        return ans;
+    }
+}
+```
+
+#### C++
+
+```cpp
+class Solution {
+public:
+    int minRemoval(vector<int>& nums, int k) {
+        ranges::sort(nums);
+        int n = nums.size();
+        int ans = n;
+        int r = 0;
+        for (int l = 0; l < n; l++) {
+            while (r < n && nums[r] <= (long long) nums[l] * k) {
+                r++;
+            }
+            ans = min(ans, n - (r - l));
+        }
+        return ans;
+    }
+};
+```
+
+#### TypeScript
+
+```ts
+function minRemoval(nums: number[], k: number): number {
+    nums.sort((a, b) => a - b);
+    const n = nums.length;
+    let ans = n;
+    let r = 0;
+    for (let l = 0; l < n; l++) {
+        while (r < n && nums[r] <= nums[l] * k) {
+            r++;
+        }
+        ans = Math.min(ans, n - (r - l));
+    }
+    return ans;
+}
+```
+
+<!-- tabs:end -->
+
+<!-- solution:end -->
+
 <!-- problem:end -->