feat: add solutions to lc problems: No.2432, 2433

Author: YangFong

solution/2400-2499/2432.The Employee That Worked on the Longest Task/README.md

@@ -169,6 +169,27 @@ func hardestWorker(n int, logs [][]int) int {
 }
 ```
 
+### **C**
+
+```c
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+
+int hardestWorker(int n, int **logs, int logsSize, int *logsColSize) {
+    int res = 0;
+    int max = 0;
+    int pre = 0;
+    for (int i = 0; i < logsSize; i++) {
+        int t = logs[i][1] - pre;
+        if (t > max || (t == max && res > logs[i][0])) {
+            res = logs[i][0];
+            max = t;
+        }
+        pre = logs[i][1];
+    }
+    return res;
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -186,6 +207,27 @@ function hardestWorker(n: number, logs: number[][]): number {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn hardest_worker(n: i32, logs: Vec<Vec<i32>>) -> i32 {
+        let mut res = 0;
+        let mut max = 0;
+        let mut pre = 0;
+        for log in logs.iter() {
+            let t = log[1] - pre;
+            if t > max || t == max && res > log[0] {
+                res = log[0];
+                max = t;
+            }
+            pre = log[1];
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2400-2499/2432.The Employee That Worked on the Longest Task/README_EN.md

@@ -153,6 +153,27 @@ func hardestWorker(n int, logs [][]int) int {
 }
 ```
 
+### **C**
+
+```c
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+
+int hardestWorker(int n, int **logs, int logsSize, int *logsColSize) {
+    int res = 0;
+    int max = 0;
+    int pre = 0;
+    for (int i = 0; i < logsSize; i++) {
+        int t = logs[i][1] - pre;
+        if (t > max || (t == max && res > logs[i][0])) {
+            res = logs[i][0];
+            max = t;
+        }
+        pre = logs[i][1];
+    }
+    return res;
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -170,6 +191,27 @@ function hardestWorker(n: number, logs: number[][]): number {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn hardest_worker(n: i32, logs: Vec<Vec<i32>>) -> i32 {
+        let mut res = 0;
+        let mut max = 0;
+        let mut pre = 0;
+        for log in logs.iter() {
+            let t = log[1] - pre;
+            if t > max || t == max && res > log[0] {
+                res = log[0];
+                max = t;
+            }
+            pre = log[1];
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2400-2499/2432.The Employee That Worked on the Longest Task/Solution.c

@@ -0,0 +1,16 @@
+#define min(a,b) (((a) < (b)) ? (a) : (b))
+
+int hardestWorker(int n, int **logs, int logsSize, int *logsColSize) {
+    int res = 0;
+    int max = 0;
+    int pre = 0;
+    for (int i = 0; i < logsSize; i++) {
+        int t = logs[i][1] - pre;
+        if (t > max || (t == max && res > logs[i][0])) {
+            res = logs[i][0];
+            max = t;
+        }
+        pre = logs[i][1];
+    }
+    return res;
+}

solution/2400-2499/2432.The Employee That Worked on the Longest Task/Solution.rs

@@ -0,0 +1,16 @@
+impl Solution {
+    pub fn hardest_worker(n: i32, logs: Vec<Vec<i32>>) -> i32 {
+        let mut res = 0;
+        let mut max = 0;
+        let mut pre = 0;
+        for log in logs.iter() {
+            let t = log[1] - pre;
+            if t > max || t == max && res > log[0] {
+                res = log[0];
+                max = t;
+            }
+            pre = log[1];
+        }
+        res
+    }
+}

solution/2400-2499/2433.Find The Original Array of Prefix Xor/README.md

@@ -136,6 +136,23 @@ func findArray(pref []int) []int {
 }
 ```
 
+### **C**
+
+```c
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int *findArray(int *pref, int prefSize, int *returnSize) {
+    int *res = (int *) malloc(sizeof(int) * prefSize);
+    res[0] = pref[0];
+    for (int i = 1; i < prefSize; i++) {
+        res[i] = pref[i - 1] ^ pref[i];
+    }
+    *returnSize = prefSize;
+    return res;
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -148,6 +165,22 @@ function findArray(pref: number[]): number[] {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn find_array(pref: Vec<i32>) -> Vec<i32> {
+        let n = pref.len();
+        let mut res = vec![0; n];
+        res[0] = pref[0];
+        for i in 1..n {
+            res[i] = pref[i] ^ pref[i - 1];
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2400-2499/2433.Find The Original Array of Prefix Xor/README_EN.md

@@ -104,6 +104,23 @@ func findArray(pref []int) []int {
 }
 ```
 
+### **C**
+
+```c
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int *findArray(int *pref, int prefSize, int *returnSize) {
+    int *res = (int *) malloc(sizeof(int) * prefSize);
+    res[0] = pref[0];
+    for (int i = 1; i < prefSize; i++) {
+        res[i] = pref[i - 1] ^ pref[i];
+    }
+    *returnSize = prefSize;
+    return res;
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -116,6 +133,22 @@ function findArray(pref: number[]): number[] {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn find_array(pref: Vec<i32>) -> Vec<i32> {
+        let n = pref.len();
+        let mut res = vec![0; n];
+        res[0] = pref[0];
+        for i in 1..n {
+            res[i] = pref[i] ^ pref[i - 1];
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2400-2499/2433.Find The Original Array of Prefix Xor/Solution.c

@@ -0,0 +1,12 @@
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int *findArray(int *pref, int prefSize, int *returnSize) {
+    int *res = (int *) malloc(sizeof(int) * prefSize);
+    res[0] = pref[0];
+    for (int i = 1; i < prefSize; i++) {
+        res[i] = pref[i - 1] ^ pref[i];
+    }
+    *returnSize = prefSize;
+    return res;
+}

solution/2400-2499/2433.Find The Original Array of Prefix Xor/Solution.rs

@@ -0,0 +1,11 @@
+impl Solution {
+    pub fn find_array(pref: Vec<i32>) -> Vec<i32> {
+        let n = pref.len();
+        let mut res = vec![0; n];
+        res[0] = pref[0];
+        for i in 1..n {
+            res[i] = pref[i] ^ pref[i - 1];
+        }
+        res
+    }
+}