feat: add solutions to lc problems: No.3224~3226 (#4715)

Author: yanglbme

solution/3200-3299/3224.Minimum Array Changes to Make Differences Equal/README.md

@@ -240,6 +240,34 @@ function minChanges(nums: number[], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn min_changes(nums: Vec<i32>, k: i32) -> i32 {
+        let n = nums.len();
+        let mut d = vec![0; (k + 2) as usize];
+        for i in 0..n / 2 {
+            let x = nums[i].min(nums[n - i - 1]);
+            let y = nums[i].max(nums[n - i - 1]);
+            d[0] += 1;
+            d[(y - x) as usize] -= 1;
+            d[(y - x + 1) as usize] += 1;
+            let idx = (y.max(k - x) + 1) as usize;
+            d[idx] -= 1;
+            d[idx] += 2;
+        }
+        let mut ans = n as i32;
+        let mut s = 0;
+        for x in d {
+            s += x;
+            ans = ans.min(s);
+        }
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3200-3299/3224.Minimum Array Changes to Make Differences Equal/README_EN.md

@@ -238,6 +238,34 @@ function minChanges(nums: number[], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn min_changes(nums: Vec<i32>, k: i32) -> i32 {
+        let n = nums.len();
+        let mut d = vec![0; (k + 2) as usize];
+        for i in 0..n / 2 {
+            let x = nums[i].min(nums[n - i - 1]);
+            let y = nums[i].max(nums[n - i - 1]);
+            d[0] += 1;
+            d[(y - x) as usize] -= 1;
+            d[(y - x + 1) as usize] += 1;
+            let idx = (y.max(k - x) + 1) as usize;
+            d[idx] -= 1;
+            d[idx] += 2;
+        }
+        let mut ans = n as i32;
+        let mut s = 0;
+        for x in d {
+            s += x;
+            ans = ans.min(s);
+        }
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3200-3299/3224.Minimum Array Changes to Make Differences Equal/Solution.rs

@@ -0,0 +1,23 @@
+impl Solution {
+    pub fn min_changes(nums: Vec<i32>, k: i32) -> i32 {
+        let n = nums.len();
+        let mut d = vec![0; (k + 2) as usize];
+        for i in 0..n / 2 {
+            let x = nums[i].min(nums[n - i - 1]);
+            let y = nums[i].max(nums[n - i - 1]);
+            d[0] += 1;
+            d[(y - x) as usize] -= 1;
+            d[(y - x + 1) as usize] += 1;
+            let idx = (y.max(k - x) + 1) as usize;
+            d[idx] -= 1;
+            d[idx] += 2;
+        }
+        let mut ans = n as i32;
+        let mut s = 0;
+        for x in d {
+            s += x;
+            ans = ans.min(s);
+        }
+        ans
+    }
+}

solution/3200-3299/3225.Maximum Score From Grid Operations/images/rectangles.png

@@ -140,6 +140,30 @@ function bitCount(i: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn min_changes(n: i32, k: i32) -> i32 {
+        if (n & k) != k {
+            -1
+        } else {
+            (n ^ k).count_ones() as i32
+        }
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int MinChanges(int n, int k) {
+        return (n & k) != k ? -1 : BitOperations.PopCount((uint)(n ^ k));
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3200-3299/3226.Number of Bit Changes to Make Two Integers Equal/README.md

@@ -137,6 +137,30 @@ function bitCount(i: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn min_changes(n: i32, k: i32) -> i32 {
+        if (n & k) != k {
+            -1
+        } else {
+            (n ^ k).count_ones() as i32
+        }
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int MinChanges(int n, int k) {
+        return (n & k) != k ? -1 : BitOperations.PopCount((uint)(n ^ k));
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3200-3299/3226.Number of Bit Changes to Make Two Integers Equal/README_EN.md

@@ -0,0 +1,5 @@
+public class Solution {
+    public int MinChanges(int n, int k) {
+        return (n & k) != k ? -1 : BitOperations.PopCount((uint)(n ^ k));
+    }
+}

solution/3200-3299/3226.Number of Bit Changes to Make Two Integers Equal/Solution.cs

@@ -0,0 +1,9 @@
+impl Solution {
+    pub fn min_changes(n: i32, k: i32) -> i32 {
+        if (n & k) != k {
+            -1
+        } else {
+            (n ^ k).count_ones() as i32
+        }
+    }
+}