feat: add solutions to lc problems: No.271,276

* No.0271.Encode and Decode Strings
* No.0276.Paint Fence

Author: yanglbme

solution/0200-0299/0266.Palindrome Permutation/README.md

@@ -131,12 +131,4 @@ var canPermutePalindrome = function (s) {
 
 <!-- tabs:end -->
 
-### 方法二：哈希表
-
-利用哈希表来维护元素。遍历字符串每个字母 $s[i]$，若 $s[i]$ 在哈希表中，则将 $s[i]$ 从哈希表中删除，否则将 $s[i]$ 加入哈希表。
-
-遍历结束，若哈希表中元素个数不超过 $1$，则返回 $true$，否则返回 $false$。
-
-时间复杂度 $O(n)$，空间复杂度 $O(|\Sigma|)$。其中 $n$ 是字符串的长度，而 $|\Sigma|$ 是字符集的大小，本题中字符集为小写字母，因此 $|\Sigma|=26$。
-
 <!-- end -->

solution/0200-0299/0271.Encode and Decode Strings/README.md

@@ -49,9 +49,11 @@
 
 ## 解法
 
-### 方法一：使用非 ASCII 码的分隔符
+### 方法一：编码字符串长度
 
-Python 中可以直接 `chr(257)` 作为字符串的分隔符，这样就可以实现字符串的编码和解码。
+编码时，将字符串的长度转成固定 $4$ 位的字符串，加上字符串本身，依次拼接到结果字符串。
+
+解码时，先取前四位字符串，得到长度，再通过长度截取后面的字符串。依次截取，最终得到字符串列表。
 
 时间复杂度 $O(n)$。
 
@@ -61,11 +63,21 @@ Python 中可以直接 `chr(257)` 作为字符串的分隔符，这样就可以
 class Codec:
     def encode(self, strs: List[str]) -> str:
         """Encodes a list of strings to a single string."""
-        return chr(257).join(strs)
+        ans = []
+        for s in strs:
+            ans.append('{:4}'.format(len(s)) + s)
+        return ''.join(ans)
 
     def decode(self, s: str) -> List[str]:
         """Decodes a single string to a list of strings."""
-        return s.split(chr(257))
+        ans = []
+        i, n = 0, len(s)
+        while i < n:
+            size = int(s[i : i + 4])
+            i += 4
+            ans.append(s[i : i + size])
+            i += size
+        return ans
 
 
 # Your Codec object will be instantiated and called as such:
@@ -173,42 +185,4 @@ func (codec *Codec) Decode(strs string) []string {
 
 <!-- tabs:end -->
 
-### 方法二：编码字符串长度
-
-编码时，将字符串的长度转成固定 $4$ 位的字符串，加上字符串本身，依次拼接到结果字符串。
-
-解码时，先取前四位字符串，得到长度，再通过长度截取后面的字符串。依次截取，最终得到字符串列表。
-
-时间复杂度 $O(n)$。
-
-<!-- tabs:start -->
-
-```python
-class Codec:
-    def encode(self, strs: List[str]) -> str:
-        """Encodes a list of strings to a single string."""
-        ans = []
-        for s in strs:
-            ans.append('{:4}'.format(len(s)) + s)
-        return ''.join(ans)
-
-    def decode(self, s: str) -> List[str]:
-        """Decodes a single string to a list of strings."""
-        ans = []
-        i, n = 0, len(s)
-        while i < n:
-            size = int(s[i : i + 4])
-            i += 4
-            ans.append(s[i : i + size])
-            i += size
-        return ans
-
-
-# Your Codec object will be instantiated and called as such:
-# codec = Codec()
-# codec.decode(codec.encode(strs))
-```
-
-<!-- tabs:end -->
-
 <!-- end -->

solution/0200-0299/0271.Encode and Decode Strings/README_EN.md

@@ -81,19 +81,35 @@ String[] strs = decoder.decode(msg);
 
 ## Solutions
 
-### Solution 1
+### Solution 1: Encode String Length
+
+During encoding, we convert the length of the string into a fixed 4-digit string, add the string itself, and append it to the result string in sequence.
+
+During decoding, we first take the first four digits of the string to get the length, and then cut the following string according to the length. We cut it in sequence until we get the list of strings.
+
+The time complexity is $O(n)$.
 
 <!-- tabs:start -->
 
 ```python
 class Codec:
     def encode(self, strs: List[str]) -> str:
         """Encodes a list of strings to a single string."""
-        return chr(257).join(strs)
+        ans = []
+        for s in strs:
+            ans.append('{:4}'.format(len(s)) + s)
+        return ''.join(ans)
 
     def decode(self, s: str) -> List[str]:
         """Decodes a single string to a list of strings."""
-        return s.split(chr(257))
+        ans = []
+        i, n = 0, len(s)
+        while i < n:
+            size = int(s[i : i + 4])
+            i += 4
+            ans.append(s[i : i + size])
+            i += size
+        return ans
 
 
 # Your Codec object will be instantiated and called as such:
@@ -201,36 +217,4 @@ func (codec *Codec) Decode(strs string) []string {
 
 <!-- tabs:end -->
 
-### Solution 2
-
-<!-- tabs:start -->
-
-```python
-class Codec:
-    def encode(self, strs: List[str]) -> str:
-        """Encodes a list of strings to a single string."""
-        ans = []
-        for s in strs:
-            ans.append('{:4}'.format(len(s)) + s)
-        return ''.join(ans)
-
-    def decode(self, s: str) -> List[str]:
-        """Decodes a single string to a list of strings."""
-        ans = []
-        i, n = 0, len(s)
-        while i < n:
-            size = int(s[i : i + 4])
-            i += 4
-            ans.append(s[i : i + size])
-            i += size
-        return ans
-
-
-# Your Codec object will be instantiated and called as such:
-# codec = Codec()
-# codec.decode(codec.encode(strs))
-```
-
-<!-- tabs:end -->
-
 <!-- end -->

solution/0200-0299/0271.Encode and Decode Strings/Solution.py

@@ -1,11 +1,21 @@
 class Codec:
     def encode(self, strs: List[str]) -> str:
         """Encodes a list of strings to a single string."""
-        return chr(257).join(strs)
+        ans = []
+        for s in strs:
+            ans.append("{:4}".format(len(s)) + s)
+        return "".join(ans)
 
     def decode(self, s: str) -> List[str]:
         """Decodes a single string to a list of strings."""
-        return s.split(chr(257))
+        ans = []
+        i, n = 0, len(s)
+        while i < n:
+            size = int(s[i : i + 4])
+            i += 4
+            ans.append(s[i : i + size])
+            i += size
+        return ans
 
 
 # Your Codec object will be instantiated and called as such: