feat: add solutions to lc problems: No.1047, 2130

- No.1047.Remove All Adjacent Duplicates In String
- No.2130.Maximum Twin Sum of a Linked List

Author: YangFong

solution/1000-1099/1047.Remove All Adjacent Duplicates In String/README.md

@@ -136,6 +136,44 @@ var removeDuplicates = function (s) {
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn remove_duplicates(s: String) -> String {
+        let mut stack = Vec::new();
+        for c in s.chars() {
+            if !stack.is_empty() && *stack.last().unwrap() == c {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        stack.into_iter().collect()
+    }
+}
+```
+
+### **C**
+
+```c
+char *removeDuplicates(char *s) {
+    int n = strlen(s);
+    char *stack = malloc(sizeof(char) * (n + 1));
+    int i = 0;
+    for (int j = 0; j < n; j++) {
+        char c = s[j];
+        if (i && stack[i - 1] == c) {
+            i--;
+        } else {
+            stack[i++] = c;
+        }
+    }
+    stack[i] = '\0';
+    return stack;
+}
+```
+
 ### **...**
 
 ```

solution/1000-1099/1047.Remove All Adjacent Duplicates In String/README_EN.md

@@ -126,6 +126,44 @@ var removeDuplicates = function (s) {
 };
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn remove_duplicates(s: String) -> String {
+        let mut stack = Vec::new();
+        for c in s.chars() {
+            if !stack.is_empty() && *stack.last().unwrap() == c {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        stack.into_iter().collect()
+    }
+}
+```
+
+### **C**
+
+```c
+char *removeDuplicates(char *s) {
+    int n = strlen(s);
+    char *stack = malloc(sizeof(char) * (n + 1));
+    int i = 0;
+    for (int j = 0; j < n; j++) {
+        char c = s[j];
+        if (i && stack[i - 1] == c) {
+            i--;
+        } else {
+            stack[i++] = c;
+        }
+    }
+    stack[i] = '\0';
+    return stack;
+}
+```
+
 ### **...**
 
 ```

solution/1000-1099/1047.Remove All Adjacent Duplicates In String/Solution.c

@@ -0,0 +1,15 @@
+char *removeDuplicates(char *s) {
+    int n = strlen(s);
+    char *stack = malloc(sizeof(char) * (n + 1));
+    int i = 0;
+    for (int j = 0; j < n; j++) {
+        char c = s[j];
+        if (i && stack[i - 1] == c) {
+            i--;
+        } else {
+            stack[i++] = c;
+        }
+    }
+    stack[i] = '\0';
+    return stack;
+}

solution/1000-1099/1047.Remove All Adjacent Duplicates In String/Solution.rs

@@ -0,0 +1,13 @@
+impl Solution {
+    pub fn remove_duplicates(s: String) -> String {
+        let mut stack = Vec::new();
+        for c in s.chars() {
+            if !stack.is_empty() && *stack.last().unwrap() == c {
+                stack.pop();
+            } else {
+                stack.push(c);
+            }
+        }
+        stack.into_iter().collect()
+    }
+}

solution/2100-2199/2130.Maximum Twin Sum of a Linked List/README.md

@@ -352,10 +352,110 @@ func max(a, b int) int {
 
 ### **TypeScript**
 
-<!-- 这里可写当前语言的特殊实现逻辑 -->
+```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function pairSum(head: ListNode | null): number {
+    const arr = [];
+    let node = head;
+    while (node) {
+        arr.push(node.val);
+        node = node.next;
+    }
+    const n = arr.length;
+    let ans = 0;
+    for (let i = 0; i < n >> 1; i++) {
+        ans = Math.max(ans, arr[i] + arr[n - 1 - i]);
+    }
+    return ans;
+}
+```
 
 ```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function pairSum(head: ListNode | null): number {
+    let fast = head;
+    let slow = head;
+    while (fast) {
+        fast = fast.next.next;
+        slow = slow.next;
+    }
+    let prev = null;
+    while (slow) {
+        const next = slow.next;
+        slow.next = prev;
+        prev = slow;
+        slow = next;
+    }
+    let left = head;
+    let right = prev;
+    let ans = 0;
+    while (left && right) {
+        ans = Math.max(ans, left.val + right.val);
+        left = left.next;
+        right = right.next;
+    }
+    return ans;
+}
+```
 
+### **Rust**
+
+```rust
+// Definition for singly-linked list.
+// #[derive(PartialEq, Eq, Clone, Debug)]
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+//
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+impl Solution {
+    pub fn pair_sum(head: Option<Box<ListNode>>) -> i32 {
+        let mut arr = Vec::new();
+        let mut node = &head;
+        while node.is_some() {
+            let t = node.as_ref().unwrap();
+            arr.push(t.val);
+            node = &t.next;
+        }
+        let n = arr.len();
+        let mut ans = 0;
+        for i in 0..n >> 1 {
+            ans = ans.max(arr[i] + arr[n - 1 - i]);
+        }
+        ans
+    }
+}
 ```
 
 ### **...**

solution/2100-2199/2130.Maximum Twin Sum of a Linked List/README_EN.md

@@ -332,7 +332,109 @@ func max(a, b int) int {
 ### **TypeScript**
 
 ```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
 
+function pairSum(head: ListNode | null): number {
+    const arr = [];
+    let node = head;
+    while (node) {
+        arr.push(node.val);
+        node = node.next;
+    }
+    const n = arr.length;
+    let ans = 0;
+    for (let i = 0; i < n >> 1; i++) {
+        ans = Math.max(ans, arr[i] + arr[n - 1 - i]);
+    }
+    return ans;
+}
+```
+
+```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+function pairSum(head: ListNode | null): number {
+    let fast = head;
+    let slow = head;
+    while (fast) {
+        fast = fast.next.next;
+        slow = slow.next;
+    }
+    let prev = null;
+    while (slow) {
+        const next = slow.next;
+        slow.next = prev;
+        prev = slow;
+        slow = next;
+    }
+    let left = head;
+    let right = prev;
+    let ans = 0;
+    while (left && right) {
+        ans = Math.max(ans, left.val + right.val);
+        left = left.next;
+        right = right.next;
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+// Definition for singly-linked list.
+// #[derive(PartialEq, Eq, Clone, Debug)]
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+//
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+impl Solution {
+    pub fn pair_sum(head: Option<Box<ListNode>>) -> i32 {
+        let mut arr = Vec::new();
+        let mut node = &head;
+        while node.is_some() {
+            let t = node.as_ref().unwrap();
+            arr.push(t.val);
+            node = &t.next;
+        }
+        let n = arr.len();
+        let mut ans = 0;
+        for i in 0..n >> 1 {
+            ans = ans.max(arr[i] + arr[n - 1 - i]);
+        }
+        ans
+    }
+}
 ```
 
 ### **...**

solution/2100-2199/2130.Maximum Twin Sum of a Linked List/Solution.rs

@@ -0,0 +1,33 @@
+// Definition for singly-linked list.
+// #[derive(PartialEq, Eq, Clone, Debug)]
+// pub struct ListNode {
+//   pub val: i32,
+//   pub next: Option<Box<ListNode>>
+// }
+//
+// impl ListNode {
+//   #[inline]
+//   fn new(val: i32) -> Self {
+//     ListNode {
+//       next: None,
+//       val
+//     }
+//   }
+// }
+impl Solution {
+    pub fn pair_sum(head: Option<Box<ListNode>>) -> i32 {
+        let mut arr = Vec::new();
+        let mut node = &head;
+        while node.is_some() {
+            let t = node.as_ref().unwrap();
+            arr.push(t.val);
+            node = &t.next;
+        }
+        let n = arr.len();
+        let mut ans = 0;
+        for i in 0..n >> 1 {
+            ans = ans.max(arr[i] + arr[n - 1 - i]);
+        }
+        ans
+    }
+}