feat: add solutions to lc problems: No.0344,0345

solution/0300-0399/0344.Reverse String/README.md

@@ -38,6 +38,12 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：双指针**
+
+我们用两个指针 $i$ 和 $j$，初始时分别指向数组的首尾，每次将 $i$ 和 $j$ 对应的元素交换，然后 $i$ 向后移动，$j$ 向前移动，直到 $i$ 和 $j$ 相遇。
+
+时间复杂度 $O(n)$，其中 $n$ 是数组的长度。空间复杂度 $O(1)$。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -47,9 +53,15 @@
 ```python
 class Solution:
     def reverseString(self, s: List[str]) -> None:
-        """
-        Do not return anything, modify s in-place instead.
-        """
+        i, j = 0, len(s) - 1
+        while i < j:
+            s[i], s[j] = s[j], s[i]
+            i, j = i + 1, j - 1
+```
+
+```python
+class Solution:
+    def reverseString(self, s: List[str]) -> None:
         s[:] = s[::-1]
 ```
 
@@ -75,8 +87,9 @@ class Solution {
 class Solution {
 public:
     void reverseString(vector<char>& s) {
-        for (int i = 0, j = s.size() - 1; i < j; ++i, --j)
-            swap(s[i], s[j]);
+        for (int i = 0, j = s.size() - 1; i < j;) {
+            swap(s[i++], s[j--]);
+        }
     }
 };
 ```
@@ -91,6 +104,19 @@ func reverseString(s []byte) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+/**
+ Do not return anything, modify s in-place instead.
+ */
+function reverseString(s: string[]): void {
+    for (let i = 0, j = s.length - 1; i < j; ++i, --j) {
+        [s[i], s[j]] = [s[j], s[i]];
+    }
+}
+```
+
 ### **JavaScript**
 
 ```js
@@ -110,13 +136,12 @@ var reverseString = function (s) {
 ```rust
 impl Solution {
     pub fn reverse_string(s: &mut Vec<char>) {
-        let n = s.len();
-        let mut l = 0;
-        let mut r = n - 1;
-        while l < r {
-            s.swap(l, r);
-            l += 1;
-            r -= 1;
+        let mut i = 0;
+        let mut j = s.len() - 1;
+        while i < j {
+            s.swap(i, j);
+            i += 1;
+            j -= 1;
         }
     }
 }

solution/0300-0399/0344.Reverse String/README_EN.md

@@ -33,9 +33,15 @@
 ```python
 class Solution:
     def reverseString(self, s: List[str]) -> None:
-        """
-        Do not return anything, modify s in-place instead.
-        """
+        i, j = 0, len(s) - 1
+        while i < j:
+            s[i], s[j] = s[j], s[i]
+            i, j = i + 1, j - 1
+```
+
+```python
+class Solution:
+    def reverseString(self, s: List[str]) -> None:
         s[:] = s[::-1]
 ```
 
@@ -59,8 +65,9 @@ class Solution {
 class Solution {
 public:
     void reverseString(vector<char>& s) {
-        for (int i = 0, j = s.size() - 1; i < j; ++i, --j)
-            swap(s[i], s[j]);
+        for (int i = 0, j = s.size() - 1; i < j;) {
+            swap(s[i++], s[j--]);
+        }
     }
 };
 ```
@@ -75,6 +82,19 @@ func reverseString(s []byte) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+/**
+ Do not return anything, modify s in-place instead.
+ */
+function reverseString(s: string[]): void {
+    for (let i = 0, j = s.length - 1; i < j; ++i, --j) {
+        [s[i], s[j]] = [s[j], s[i]];
+    }
+}
+```
+
 ### **JavaScript**
 
 ```js
@@ -94,13 +114,12 @@ var reverseString = function (s) {
 ```rust
 impl Solution {
     pub fn reverse_string(s: &mut Vec<char>) {
-        let n = s.len();
-        let mut l = 0;
-        let mut r = n - 1;
-        while l < r {
-            s.swap(l, r);
-            l += 1;
-            r -= 1;
+        let mut i = 0;
+        let mut j = s.len() - 1;
+        while i < j {
+            s.swap(i, j);
+            i += 1;
+            j -= 1;
         }
     }
 }

solution/0300-0399/0344.Reverse String/Solution.cpp

@@ -1,7 +1,8 @@
-class Solution {
-public:
-    void reverseString(vector<char>& s) {
-        for (int i = 0, j = s.size() - 1; i < j; ++i, --j)
-            swap(s[i], s[j]);
-    }
+class Solution {
+public:
+    void reverseString(vector<char>& s) {
+        for (int i = 0, j = s.size() - 1; i < j;) {
+            swap(s[i++], s[j--]);
+        }
+    }
 };

solution/0300-0399/0344.Reverse String/Solution.py

@@ -1,6 +1,6 @@
-class Solution:
-    def reverseString(self, s: List[str]) -> None:
-        """
-        Do not return anything, modify s in-place instead.
-        """
-        s[:] = s[::-1]
+class Solution:
+    def reverseString(self, s: List[str]) -> None:
+        i, j = 0, len(s) - 1
+        while i < j:
+            s[i], s[j] = s[j], s[i]
+            i, j = i + 1, j - 1

solution/0300-0399/0344.Reverse String/Solution.rs

@@ -1,12 +1,11 @@
-impl Solution {
-    pub fn reverse_string(s: &mut Vec<char>) {
-        let n = s.len();
-        let mut l = 0;
-        let mut r = n - 1;
-        while l < r {
-            s.swap(l, r);
-            l += 1;
-            r -= 1;
-        }
-    }
-}
+impl Solution {
+    pub fn reverse_string(s: &mut Vec<char>) {
+        let mut i = 0;
+        let mut j = s.len() - 1;
+        while i < j {
+            s.swap(i, j);
+            i += 1;
+            j -= 1;
+        }
+    }
+}

solution/0300-0399/0344.Reverse String/Solution.ts

@@ -0,0 +1,8 @@
+/**
+ Do not return anything, modify s in-place instead.
+ */
+function reverseString(s: string[]): void {
+    for (let i = 0, j = s.length - 1; i < j; ++i, --j) {
+        [s[i], s[j]] = [s[j], s[i]];
+    }
+}

solution/0300-0399/0345.Reverse Vowels of a String/README.md

@@ -38,9 +38,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-将字符串转为字符数组（或列表），定义双指针 i、j，分别指向数组（列表）头部和尾部，当 i、j 指向的字符均为元音字母时，进行交换。
+**方法一：双指针**
 
-依次遍历，当 `i >= j` 时，遍历结束。将字符数组（列表）转为字符串返回即可。
+我们可以用两个指针 $i$ 和 $j$，初始时分别指向字符串的首尾。
+
+每次循环判断 $i$ 指向的字符是否是元音字母，如果不是则向后移动 $i$；同理，判断 $j$ 指向的字符是否是元音字母，如果不是则向前移动 $j$。如果此时 $i \lt j$，那么 $i$ 和 $j$ 指向的字符都是元音字母，交换这两个字符。然后向后移动 $i$，向前移动 $j$。继续上述操作，直到 $i \ge j$。
+
+时间复杂度 $O(n)$，其中 $n$ 是字符串的长度。空间复杂度 $O(|\Sigma|)$，其中 $\Sigma$ 是字符集的大小。
 
 <!-- tabs:start -->
 
@@ -51,20 +55,18 @@
 ```python
 class Solution:
     def reverseVowels(self, s: str) -> str:
-        vowels = {'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'}
+        vowels = "aeiouAEIOU"
         i, j = 0, len(s) - 1
-        chars = list(s)
+        cs = list(s)
         while i < j:
-            if chars[i] not in vowels:
+            while i < j and cs[i] not in vowels:
                 i += 1
-                continue
-            if chars[j] not in vowels:
+            while i < j and cs[j] not in vowels:
                 j -= 1
-                continue
-            chars[i], chars[j] = chars[j], chars[i]
-            i += 1
-            j -= 1
-        return ''.join(chars)
+            if i < j:
+                cs[i], cs[j] = cs[j], cs[i]
+                i, j = i + 1, j - 1
+        return "".join(cs)
 ```
 
 ### **Java**
@@ -74,55 +76,102 @@ class Solution:
 ```java
 class Solution {
     public String reverseVowels(String s) {
-        Set<Character> vowels
-            = new HashSet<>(Arrays.asList('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'));
-        int i = 0, j = s.length() - 1;
-        char[] chars = s.toCharArray();
+        boolean[] vowels = new boolean[128];
+        for (char c : "aeiouAEIOU".toCharArray()) {
+            vowels[c] = true;
+        }
+        char[] cs = s.toCharArray();
+        int i = 0, j = cs.length - 1;
         while (i < j) {
-            if (!vowels.contains(chars[i])) {
+            while (i < j && !vowels[cs[i]]) {
                 ++i;
-                continue;
             }
-            if (!vowels.contains(chars[j])) {
+            while (i < j && !vowels[cs[j]]) {
+                --j;
+            }
+            if (i < j) {
+                char t = cs[i];
+                cs[i] = cs[j];
+                cs[j] = t;
+                ++i;
                 --j;
-                continue;
             }
-            char t = chars[i];
-            chars[i] = chars[j];
-            chars[j] = t;
-            ++i;
-            --j;
         }
-        return new String(chars);
+        return String.valueOf(cs);
     }
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string reverseVowels(string s) {
+        bool vowels[128];
+        memset(vowels, false, sizeof(vowels));
+        for (char c : "aeiouAEIOU") {
+            vowels[c] = true;
+        }
+        int i = 0, j = s.size() - 1;
+        while (i < j) {
+            while (i < j && !vowels[s[i]]) {
+                ++i;
+            }
+            while (i < j && !vowels[s[j]]) {
+                --j;
+            }
+            if (i < j) {
+                swap(s[i++], s[j--]);
+            }
+        }
+        return s;
+    }
+};
+```
+
 ### **Go**
 
 ```go
 func reverseVowels(s string) string {
-	left, right := 0, len(s)-1
-	a := []byte(s)
-	for left < right {
-		for left < right && !isVowel(a[left]) {
-			left++
+	vowels := [128]bool{}
+	for _, c := range "aeiouAEIOU" {
+		vowels[c] = true
+	}
+	cs := []byte(s)
+	i, j := 0, len(cs)-1
+	for i < j {
+		for i < j && !vowels[cs[i]] {
+			i++
 		}
-		for left < right && !isVowel(a[right]) {
-			right--
+		for i < j && !vowels[cs[j]] {
+			j--
 		}
-		if left != right && isVowel(a[left]) && isVowel(a[right]) {
-			a[left], a[right] = a[right], a[left]
-			left++
-			right--
+		if i < j {
+			cs[i], cs[j] = cs[j], cs[i]
+			i, j = i+1, j-1
 		}
 	}
-	return string(a)
+	return string(cs)
 }
+```
+
+### **TypeScript**
 
-func isVowel(b byte) bool {
-	return b == 'a' || b == 'e' || b == 'i' || b == 'o' || b == 'u' ||
-		b == 'A' || b == 'E' || b == 'I' || b == 'O' || b == 'U'
+```ts
+function reverseVowels(s: string): string {
+    const vowels = new Set(['a', 'e', 'i', 'o', 'u']);
+    const cs = s.split('');
+    for (let i = 0, j = cs.length - 1; i < j; ++i, --j) {
+        while (i < j && !vowels.has(cs[i].toLowerCase())) {
+            ++i;
+        }
+        while (i < j && !vowels.has(cs[j].toLowerCase())) {
+            --j;
+        }
+        [cs[i], cs[j]] = [cs[j], cs[i]];
+    }
+    return cs.join('');
 }
 ```