feat: add new lc problems and update solutions

* Update solutions to lc problems: No.0242,0266,0438
* Add new lc problems: No.2084,2085,2086,2087,2088

Author: yanglbme

solution/0200-0299/0242.Valid Anagram/README.md

@@ -43,15 +43,11 @@ class Solution:
     def isAnagram(self, s: str, t: str) -> bool:
         if len(s) != len(t):
             return False
-        n = len(s)
         chars = [0] * 26
-        for i in range(n):
+        for i in range(len(s)):
             chars[ord(s[i]) - ord('a')] += 1
             chars[ord(t[i]) - ord('a')] -= 1
-        for c in chars:
-            if c != 0:
-                return False
-        return True
+        return all(c == 0 for c in chars)
 ```
 
 ### **Java**
@@ -61,12 +57,11 @@ class Solution:
 ```java
 class Solution {
     public boolean isAnagram(String s, String t) {
-        int n;
-        if ((n = s.length()) != t.length()) {
+        if (s.length() != t.length()) {
             return false;
         }
         int[] chars = new int[26];
-        for (int i = 0; i < n; ++i) {
+        for (int i = 0; i < s.length(); ++i) {
             ++chars[s.charAt(i) - 'a'];
             --chars[t.charAt(i) - 'a'];
         }
@@ -140,6 +135,27 @@ func isAnagram(s string, t string) bool {
 }
 ```
 
+
+### **JavaScript**
+
+```js
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function(s, t) {
+    if (s.length != t.length) return false;
+    let record = new Array(26).fill(0);
+    let base = 'a'.charCodeAt(0);
+    for (let i = 0; i < s.length; ++i) {
+        ++record[s.charCodeAt(i) - base];
+        --record[t.charCodeAt(i) - base];
+    }
+    return record.every(v => v == 0);
+};
+```
+
 ### **...**
 
 ```

solution/0200-0299/0242.Valid Anagram/README_EN.md

@@ -37,28 +37,23 @@ class Solution:
     def isAnagram(self, s: str, t: str) -> bool:
         if len(s) != len(t):
             return False
-        n = len(s)
         chars = [0] * 26
-        for i in range(n):
+        for i in range(len(s)):
             chars[ord(s[i]) - ord('a')] += 1
             chars[ord(t[i]) - ord('a')] -= 1
-        for c in chars:
-            if c != 0:
-                return False
-        return True
+        return all(c == 0 for c in chars)
 ```
 
 ### **Java**
 
 ```java
 class Solution {
     public boolean isAnagram(String s, String t) {
-        int n;
-        if ((n = s.length()) != t.length()) {
+        if (s.length() != t.length()) {
             return false;
         }
         int[] chars = new int[26];
-        for (int i = 0; i < n; ++i) {
+        for (int i = 0; i < s.length(); ++i) {
             ++chars[s.charAt(i) - 'a'];
             --chars[t.charAt(i) - 'a'];
         }
@@ -132,6 +127,26 @@ func isAnagram(s string, t string) bool {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isAnagram = function(s, t) {
+    if (s.length != t.length) return false;
+    let record = new Array(26).fill(0);
+    let base = 'a'.charCodeAt(0);
+    for (let i = 0; i < s.length; ++i) {
+        ++record[s.charCodeAt(i) - base];
+        --record[t.charCodeAt(i) - base];
+    }
+    return record.every(v => v == 0);
+};
+```
+
 ### **...**
 
 ```

solution/0200-0299/0242.Valid Anagram/Solution.java

@@ -1,11 +1,10 @@
 class Solution {
     public boolean isAnagram(String s, String t) {
-        int n;
-        if ((n = s.length()) != t.length()) {
+        if (s.length() != t.length()) {
             return false;
         }
         int[] chars = new int[26];
-        for (int i = 0; i < n; ++i) {
+        for (int i = 0; i < s.length(); ++i) {
             ++chars[s.charAt(i) - 'a'];
             --chars[t.charAt(i) - 'a'];
         }

solution/0200-0299/0242.Valid Anagram/Solution.js

@@ -1,27 +1,15 @@
-const isAnagram = function (s, t) {
-  let a = {},
-    b = {};
-  for (let i = 0; i < s.length; i++) {
-    if (a.hasOwnProperty(s[i])) {
-      a[s[i]]++;
-    } else {
-      a[s[i]] = 1;
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+ var isAnagram = function(s, t) {
+    if (s.length != t.length) return false;
+    let record = new Array(26).fill(0);
+    let base = 'a'.charCodeAt(0);
+    for (let i = 0; i < s.length; ++i) {
+        ++record[s.charCodeAt(i) - base];
+        --record[t.charCodeAt(i) - base];
     }
-  }
-  for (let i = 0; i < t.length; i++) {
-    if (b.hasOwnProperty(t[i])) {
-      b[t[i]]++;
-    } else {
-      b[t[i]] = 1;
-    }
-  }
-  let keyA = Object.keys(a);
-  let keyB = Object.keys(b);
-  if (keyA.length !== keyB.length) {
-    return false;
-  }
-  for (let i = 0; i < keyA.length; i++) {
-    if (a[keyA[i]] !== b[keyA[i]]) return false;
-  }
-  return true;
-};
+    return record.every(v => v == 0);
+};

solution/0200-0299/0242.Valid Anagram/Solution.py

@@ -2,12 +2,8 @@ class Solution:
     def isAnagram(self, s: str, t: str) -> bool:
         if len(s) != len(t):
             return False
-        n = len(s)
         chars = [0] * 26
-        for i in range(n):
+        for i in range(len(s)):
             chars[ord(s[i]) - ord('a')] += 1
             chars[ord(t[i]) - ord('a')] -= 1
-        for c in chars:
-            if c != 0:
-                return False
-        return True
+        return all(c == 0 for c in chars)

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

@@ -38,9 +38,8 @@
 ```python
 class Solution:
     def canPermutePalindrome(self, s: str) -> bool:
-        counter = collections.Counter(s)
-        odd_cnt = sum(e % 2 for e in counter.values())
-        return odd_cnt < 2
+        counter = Counter(s)
+        return sum(e % 2 for e in counter.values()) < 2
 ```
 
 ### **Java**

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

@@ -45,9 +45,8 @@
 ```python
 class Solution:
     def canPermutePalindrome(self, s: str) -> bool:
-        counter = collections.Counter(s)
-        odd_cnt = sum(e % 2 for e in counter.values())
-        return odd_cnt < 2
+        counter = Counter(s)
+        return sum(e % 2 for e in counter.values()) < 2
 ```
 
 ### **Java**

solution/0200-0299/0266.Palindrome Permutation/Solution.py

@@ -1,5 +1,4 @@
 class Solution:
     def canPermutePalindrome(self, s: str) -> bool:
-        counter = collections.Counter(s)
-        odd_cnt = sum(e % 2 for e in counter.values())
-        return odd_cnt < 2
+        counter = Counter(s)
+        return sum(e % 2 for e in counter.values()) < 2

solution/0400-0499/0438.Find All Anagrams in a String/README.md

@@ -63,19 +63,19 @@ s: "abab" p: "ab"
 ```python
 class Solution:
     def findAnagrams(self, s: str, p: str) -> List[int]:
-        counter = collections.Counter(p)
-        res = []
+        counter = Counter(p)
+        ans = []
         left = right = 0
-        t = collections.Counter()
+        t = Counter()
         while right < len(s):
             t[s[right]] += 1
             while t[s[right]] > counter[s[right]]:
                 t[s[left]] -= 1
                 left += 1
-            if right - left == len(p) - 1:
-                res.append(left)
+            if right - left + 1 == len(p):
+                ans.append(left)
             right += 1
-        return res
+        return ans
 ```
 
 ### **Java**
@@ -88,11 +88,11 @@ class Solution:
 class Solution {
     public List<Integer> findAnagrams(String s, String p) {
         int[] counter = new int[26];
-        for (int i = 0; i < p.length(); ++i) {
-            ++counter[p.charAt(i) - 'a'];
+        for (char c : p.toCharArray()) {
+            ++counter[c - 'a'];
         }
-        List<Integer> res = new ArrayList<>();
-        for (int i = 0; i <= s.length() - p.length(); ++i) {
+        List<Integer> ans = new ArrayList<>();
+        for (int i = 0; i + p.length() - 1 < s.length(); ++i) {
             int[] t = Arrays.copyOf(counter, counter.length);
             boolean find = true;
             for (int j = i; j < i + p.length(); ++j) {
@@ -102,10 +102,10 @@ class Solution {
                 }
             }
             if (find) {
-                res.add(i);
+                ans.add(i);
             }
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -116,10 +116,10 @@ class Solution {
 class Solution {
     public List<Integer> findAnagrams(String s, String p) {
         int[] counter = new int[26];
-        for (int i = 0; i < p.length(); ++i) {
-            ++counter[p.charAt(i) - 'a'];
+        for (char c : p.toCharArray()) {
+            ++counter[c - 'a'];
         }
-        List<Integer> res = new ArrayList<>();
+        List<Integer> ans = new ArrayList<>();
         int left = 0, right = 0;
         int[] t = new int[26];
         while (right < s.length()) {
@@ -129,16 +129,71 @@ class Solution {
                 --t[s.charAt(left) - 'a'];
                 ++left;
             }
-            if (right - left == p.length() - 1) {
-                res.add(left);
+            if (right - left + 1 == p.length()) {
+                ans.add(left);
             }
             ++right;
         }
-        return res;
+        return ans;
     }
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> findAnagrams(string s, string p) {
+        vector<int> counter(26);
+        for (char c : p) ++counter[c - 'a'];
+        vector<int> ans;
+        int left = 0, right = 0;
+        vector<int> t(26);
+        while (right < s.size())
+        {
+            int i = s[right] - 'a';
+            ++t[i];
+            while (t[i] > counter[i])
+            {
+                --t[s[left] - 'a'];
+                ++left;
+            }
+            if (right - left + 1 == p.size()) ans.push_back(left);
+            ++right;
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func findAnagrams(s string, p string) []int {
+	counter := make([]int, 26)
+	for _, c := range p {
+		counter[c-'a']++
+	}
+	var ans []int
+	left, right := 0, 0
+	t := make([]int, 26)
+	for right < len(s) {
+		i := s[right] - 'a'
+		t[i]++
+		for t[i] > counter[i] {
+			t[s[left]-'a']--
+			left++
+		}
+		if right-left+1 == len(p) {
+			ans = append(ans, left)
+		}
+		right++
+	}
+	return ans
+}
+```
+
 ### **...**
 
 ```