feat: add solutions to lc problems: No.2574, 2575

- No.2574.Left and Right Sum Differences
- No.2575.Find the Divisibility Array of a String

Author: YangFong

solution/2500-2599/2574.Left and Right Sum Differences/README.md

@@ -164,6 +164,61 @@ function leftRigthDifference(nums: number[]): number[] {
 }
 ```
 
+```ts
+function leftRigthDifference(nums: number[]): number[] {
+    let left = 0;
+    let right = nums.reduce((r, v) => r + v);
+    return nums.map(v => {
+        right -= v;
+        const res = Math.abs(left - right);
+        left += v;
+        return res;
+    });
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn left_rigth_difference(nums: Vec<i32>) -> Vec<i32> {
+        let mut left = 0;
+        let mut right = nums.iter().sum::<i32>();
+        nums.iter()
+            .map(|v| {
+                right -= v;
+                let res = (left - right).abs();
+                left += v;
+                res
+            })
+            .collect()
+    }
+}
+```
+
+### **C**
+
+```c
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int *leftRigthDifference(int *nums, int numsSize, int *returnSize) {
+    int left = 0;
+    int right = 0;
+    for (int i = 0; i < numsSize; i++) {
+        right += nums[i];
+    }
+    int *ans = malloc(sizeof(int) * numsSize);
+    for (int i = 0; i < numsSize; i++) {
+        right -= nums[i];
+        ans[i] = abs(left - right);
+        left += nums[i];
+    }
+    *returnSize = numsSize;
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2574.Left and Right Sum Differences/README_EN.md

@@ -141,6 +141,61 @@ function leftRigthDifference(nums: number[]): number[] {
 }
 ```
 
+```ts
+function leftRigthDifference(nums: number[]): number[] {
+    let left = 0;
+    let right = nums.reduce((r, v) => r + v);
+    return nums.map(v => {
+        right -= v;
+        const res = Math.abs(left - right);
+        left += v;
+        return res;
+    });
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn left_rigth_difference(nums: Vec<i32>) -> Vec<i32> {
+        let mut left = 0;
+        let mut right = nums.iter().sum::<i32>();
+        nums.iter()
+            .map(|v| {
+                right -= v;
+                let res = (left - right).abs();
+                left += v;
+                res
+            })
+            .collect()
+    }
+}
+```
+
+### **C**
+
+```c
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int *leftRigthDifference(int *nums, int numsSize, int *returnSize) {
+    int left = 0;
+    int right = 0;
+    for (int i = 0; i < numsSize; i++) {
+        right += nums[i];
+    }
+    int *ans = malloc(sizeof(int) * numsSize);
+    for (int i = 0; i < numsSize; i++) {
+        right -= nums[i];
+        ans[i] = abs(left - right);
+        left += nums[i];
+    }
+    *returnSize = numsSize;
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2574.Left and Right Sum Differences/Solution.c

@@ -0,0 +1,18 @@
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int *leftRigthDifference(int *nums, int numsSize, int *returnSize) {
+    int left = 0;
+    int right = 0;
+    for (int i = 0; i < numsSize; i++) {
+        right += nums[i];
+    }
+    int *ans = malloc(sizeof(int) * numsSize);
+    for (int i = 0; i < numsSize; i++) {
+        right -= nums[i];
+        ans[i] = abs(left - right);
+        left += nums[i];
+    }
+    *returnSize = numsSize;
+    return ans;
+}

solution/2500-2599/2574.Left and Right Sum Differences/Solution.rs

@@ -0,0 +1,14 @@
+impl Solution {
+    pub fn left_rigth_difference(nums: Vec<i32>) -> Vec<i32> {
+        let mut left = 0;
+        let mut right = nums.iter().sum::<i32>();
+        nums.iter()
+            .map(|v| {
+                right -= v;
+                let res = (left - right).abs();
+                left += v;
+                res
+            })
+            .collect()
+    }
+}

solution/2500-2599/2575.Find the Divisibility Array of a String/README.md

@@ -142,6 +142,47 @@ function divisibilityArray(word: string, m: number): number[] {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn divisibility_array(word: String, m: i32) -> Vec<i32> {
+        let m = m as i64;
+        let mut x = 0i64;
+        word.as_bytes()
+            .iter()
+            .map(|&c| {
+                x = (x * 10 + i64::from(c - b'0')) % m;
+                if x == 0 {
+                    1
+                } else {
+                    0
+                }
+            })
+            .collect()
+    }
+}
+```
+
+### **C**
+
+```c
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int *divisibilityArray(char *word, int m, int *returnSize) {
+    int n = strlen(word);
+    int *ans = malloc(sizeof(int) * n);
+    long long x = 0;
+    for (int i = 0; i < n; i++) {
+        x = (x * 10 + word[i] - '0') % m;
+        ans[i] = x == 0 ? 1 : 0;
+    }
+    *returnSize = n;
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2575.Find the Divisibility Array of a String/README_EN.md

@@ -126,6 +126,47 @@ function divisibilityArray(word: string, m: number): number[] {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn divisibility_array(word: String, m: i32) -> Vec<i32> {
+        let m = m as i64;
+        let mut x = 0i64;
+        word.as_bytes()
+            .iter()
+            .map(|&c| {
+                x = (x * 10 + i64::from(c - b'0')) % m;
+                if x == 0 {
+                    1
+                } else {
+                    0
+                }
+            })
+            .collect()
+    }
+}
+```
+
+### **C**
+
+```c
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int *divisibilityArray(char *word, int m, int *returnSize) {
+    int n = strlen(word);
+    int *ans = malloc(sizeof(int) * n);
+    long long x = 0;
+    for (int i = 0; i < n; i++) {
+        x = (x * 10 + word[i] - '0') % m;
+        ans[i] = x == 0 ? 1 : 0;
+    }
+    *returnSize = n;
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2575.Find the Divisibility Array of a String/Solution.c

@@ -0,0 +1,14 @@
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int *divisibilityArray(char *word, int m, int *returnSize) {
+    int n = strlen(word);
+    int *ans = malloc(sizeof(int) * n);
+    long long x = 0;
+    for (int i = 0; i < n; i++) {
+        x = (x * 10 + word[i] - '0') % m;
+        ans[i] = x == 0 ? 1 : 0;
+    }
+    *returnSize = n;
+    return ans;
+}

solution/2500-2599/2575.Find the Divisibility Array of a String/Solution.rs

@@ -0,0 +1,17 @@
+impl Solution {
+    pub fn divisibility_array(word: String, m: i32) -> Vec<i32> {
+        let m = m as i64;
+        let mut x = 0i64;
+        word.as_bytes()
+            .iter()
+            .map(|&c| {
+                x = (x * 10 + i64::from(c - b'0')) % m;
+                if x == 0 {
+                    1
+                } else {
+                    0
+                }
+            })
+            .collect()
+    }
+}