feat: add solutions to lc problem: No.0819

No.0819.Most Common Word

Author: yanglbme

solution/0800-0899/0819.Most Common Word/README.md

@@ -45,7 +45,9 @@ banned = ["hit"]
 
 <!-- 这里可写通用的实现逻辑 -->
 
-“正则 + 计数器”实现。
+**方法一：正则匹配/双指针 + 哈希表**
+
+正则匹配（或双指针）找出所有单词，用哈希表统计每个单词出现的频率，找到出现未在 banned 中出现且频率最大的单词。
 
 <!-- tabs:start -->
 
@@ -56,11 +58,9 @@ banned = [&quot;hit&quot;]
 ```python
 class Solution:
     def mostCommonWord(self, paragraph: str, banned: List[str]) -> str:
-        paragraph = Counter(re.findall('[a-z]+', paragraph.lower()))
-        banned_words = set(banned)
-        for word, _ in paragraph.most_common():
-            if word not in banned_words:
-                return word
+        s = set(banned)
+        p = Counter(re.findall('[a-z]+', paragraph.lower()))
+        return next(word for word, _ in p.most_common() if word not in s)
 ```
 
 ### **Java**
@@ -72,13 +72,15 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 class Solution {
+    private static Pattern pattern = Pattern.compile("[a-z]+");
+
     public String mostCommonWord(String paragraph, String[] banned) {
         Set<String> bannedWords = new HashSet<>();
         for (String word : banned) {
             bannedWords.add(word);
         }
         Map<String, Integer> counter = new HashMap<>();
-        Matcher matcher = Pattern.compile("[a-z]+").matcher(paragraph.toLowerCase());
+        Matcher matcher = pattern.matcher(paragraph.toLowerCase());
         while (matcher.find()) {
             String word = matcher.group();
             if (bannedWords.contains(word)) {
@@ -87,14 +89,14 @@ class Solution {
             counter.put(word, counter.getOrDefault(word, 0) + 1);
         }
         int max = Integer.MIN_VALUE;
-        String res = null;
+        String ans = null;
         for (Map.Entry<String, Integer> entry : counter.entrySet()) {
             if (entry.getValue() > max) {
                 max = entry.getValue();
-                res = entry.getKey();
+                ans = entry.getKey();
             }
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -144,6 +146,75 @@ impl Solution {
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string mostCommonWord(string paragraph, vector<string>& banned) {
+        unordered_set<string> s(banned.begin(), banned.end());
+        unordered_map<string, int> counter;
+        string ans;
+        for (int i = 0, mx = 0, n = paragraph.size(); i < n;)
+        {
+            if (!isalpha(paragraph[i]) && (++i > 0)) continue;
+            int j = i;
+            string word;
+            while (j < n && isalpha(paragraph[j]))
+            {
+                word.push_back(tolower(paragraph[j]));
+                ++j;
+            }
+            i = j + 1;
+            if (s.count(word)) continue;
+            ++counter[word];
+            if (counter[word] > mx)
+            {
+                ans = word;
+                mx = counter[word];
+            }
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func mostCommonWord(paragraph string, banned []string) string {
+	s := make(map[string]bool)
+	for _, w := range banned {
+		s[w] = true
+	}
+	counter := make(map[string]int)
+	var ans string
+	for i, mx, n := 0, 0, len(paragraph); i < n; {
+		if !unicode.IsLetter(rune(paragraph[i])) {
+			i++
+			continue
+		}
+		j := i
+		var word []byte
+		for j < n && unicode.IsLetter(rune(paragraph[j])) {
+			word = append(word, byte(unicode.ToLower(rune(paragraph[j]))))
+			j++
+		}
+		i = j + 1
+		t := string(word)
+		if s[t] {
+			continue
+		}
+		counter[t]++
+		if counter[t] > mx {
+			ans = t
+			mx = counter[t]
+		}
+	}
+	return ans
+}
+```
+
 ### **...**
 
 ```

solution/0800-0899/0819.Most Common Word/README_EN.md

@@ -49,11 +49,9 @@ and that "hit" isn't the answer even though it occurs more because
 ```python
 class Solution:
     def mostCommonWord(self, paragraph: str, banned: List[str]) -> str:
-        paragraph = Counter(re.findall('[a-z]+', paragraph.lower()))
-        banned_words = set(banned)
-        for word, _ in paragraph.most_common():
-            if word not in banned_words:
-                return word
+        s = set(banned)
+        p = Counter(re.findall('[a-z]+', paragraph.lower()))
+        return next(word for word, _ in p.most_common() if word not in s)
 ```
 
 ### **Java**
@@ -63,13 +61,15 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 class Solution {
+    private static Pattern pattern = Pattern.compile("[a-z]+");
+
     public String mostCommonWord(String paragraph, String[] banned) {
         Set<String> bannedWords = new HashSet<>();
         for (String word : banned) {
             bannedWords.add(word);
         }
         Map<String, Integer> counter = new HashMap<>();
-        Matcher matcher = Pattern.compile("[a-z]+").matcher(paragraph.toLowerCase());
+        Matcher matcher = pattern.matcher(paragraph.toLowerCase());
         while (matcher.find()) {
             String word = matcher.group();
             if (bannedWords.contains(word)) {
@@ -78,15 +78,84 @@ class Solution {
             counter.put(word, counter.getOrDefault(word, 0) + 1);
         }
         int max = Integer.MIN_VALUE;
-        String res = null;
+        String ans = null;
         for (Map.Entry<String, Integer> entry : counter.entrySet()) {
             if (entry.getValue() > max) {
                 max = entry.getValue();
-                res = entry.getKey();
+                ans = entry.getKey();
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    string mostCommonWord(string paragraph, vector<string>& banned) {
+        unordered_set<string> s(banned.begin(), banned.end());
+        unordered_map<string, int> counter;
+        string ans;
+        for (int i = 0, mx = 0, n = paragraph.size(); i < n;)
+        {
+            if (!isalpha(paragraph[i]) && (++i > 0)) continue;
+            int j = i;
+            string word;
+            while (j < n && isalpha(paragraph[j]))
+            {
+                word.push_back(tolower(paragraph[j]));
+                ++j;
+            }
+            i = j + 1;
+            if (s.count(word)) continue;
+            ++counter[word];
+            if (counter[word] > mx)
+            {
+                ans = word;
+                mx = counter[word];
             }
         }
-        return res;
+        return ans;
     }
+};
+```
+
+### **Go**
+
+```go
+func mostCommonWord(paragraph string, banned []string) string {
+	s := make(map[string]bool)
+	for _, w := range banned {
+		s[w] = true
+	}
+	counter := make(map[string]int)
+	var ans string
+	for i, mx, n := 0, 0, len(paragraph); i < n; {
+		if !unicode.IsLetter(rune(paragraph[i])) {
+			i++
+			continue
+		}
+		j := i
+		var word []byte
+		for j < n && unicode.IsLetter(rune(paragraph[j])) {
+			word = append(word, byte(unicode.ToLower(rune(paragraph[j]))))
+			j++
+		}
+		i = j + 1
+		t := string(word)
+		if s[t] {
+			continue
+		}
+		counter[t]++
+		if counter[t] > mx {
+			ans = t
+			mx = counter[t]
+		}
+	}
+	return ans
 }
 ```
 

solution/0800-0899/0819.Most Common Word/Solution.cpp

@@ -0,0 +1,28 @@
+class Solution {
+public:
+    string mostCommonWord(string paragraph, vector<string>& banned) {
+        unordered_set<string> s(banned.begin(), banned.end());
+        unordered_map<string, int> counter;
+        string ans;
+        for (int i = 0, mx = 0, n = paragraph.size(); i < n;)
+        {
+            if (!isalpha(paragraph[i]) && (++i > 0)) continue;
+            int j = i;
+            string word;
+            while (j < n && isalpha(paragraph[j]))
+            {
+                word.push_back(tolower(paragraph[j]));
+                ++j;
+            }
+            i = j + 1;
+            if (s.count(word)) continue;
+            ++counter[word];
+            if (counter[word] > mx)
+            {
+                ans = word;
+                mx = counter[word];
+            }
+        }
+        return ans;
+    }
+};

solution/0800-0899/0819.Most Common Word/Solution.go

@@ -0,0 +1,31 @@
+func mostCommonWord(paragraph string, banned []string) string {
+	s := make(map[string]bool)
+	for _, w := range banned {
+		s[w] = true
+	}
+	counter := make(map[string]int)
+	var ans string
+	for i, mx, n := 0, 0, len(paragraph); i < n; {
+		if !unicode.IsLetter(rune(paragraph[i])) {
+			i++
+			continue
+		}
+		j := i
+		var word []byte
+		for j < n && unicode.IsLetter(rune(paragraph[j])) {
+			word = append(word, byte(unicode.ToLower(rune(paragraph[j]))))
+			j++
+		}
+		i = j + 1
+		t := string(word)
+		if s[t] {
+			continue
+		}
+		counter[t]++
+		if counter[t] > mx {
+			ans = t
+			mx = counter[t]
+		}
+	}
+	return ans
+}

solution/0800-0899/0819.Most Common Word/Solution.java

@@ -1,29 +1,31 @@
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-class Solution {
-    public String mostCommonWord(String paragraph, String[] banned) {
-        Set<String> bannedWords = new HashSet<>();
-        for (String word : banned) {
-            bannedWords.add(word);
-        }
-        Map<String, Integer> counter = new HashMap<>();
-        Matcher matcher = Pattern.compile("[a-z]+").matcher(paragraph.toLowerCase());
-        while (matcher.find()) {
-            String word = matcher.group();
-            if (bannedWords.contains(word)) {
-                continue;
-            }
-            counter.put(word, counter.getOrDefault(word, 0) + 1);
-        }
-        int max = Integer.MIN_VALUE;
-        String res = null;
-        for (Map.Entry<String, Integer> entry : counter.entrySet()) {
-            if (entry.getValue() > max) {
-                max = entry.getValue();
-                res = entry.getKey();
-            }
-        }
-        return res;
-    }
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+class Solution {
+    private static Pattern pattern = Pattern.compile("[a-z]+");
+
+    public String mostCommonWord(String paragraph, String[] banned) {
+        Set<String> bannedWords = new HashSet<>();
+        for (String word : banned) {
+            bannedWords.add(word);
+        }
+        Map<String, Integer> counter = new HashMap<>();
+        Matcher matcher = pattern.matcher(paragraph.toLowerCase());
+        while (matcher.find()) {
+            String word = matcher.group();
+            if (bannedWords.contains(word)) {
+                continue;
+            }
+            counter.put(word, counter.getOrDefault(word, 0) + 1);
+        }
+        int max = Integer.MIN_VALUE;
+        String ans = null;
+        for (Map.Entry<String, Integer> entry : counter.entrySet()) {
+            if (entry.getValue() > max) {
+                max = entry.getValue();
+                ans = entry.getKey();
+            }
+        }
+        return ans;
+    }
 }

solution/0800-0899/0819.Most Common Word/Solution.py

@@ -1,7 +1,5 @@
-class Solution:
-    def mostCommonWord(self, paragraph: str, banned: List[str]) -> str:
-        paragraph = Counter(re.findall('[a-z]+', paragraph.lower()))
-        banned_words = set(banned)
-        for word, _ in paragraph.most_common():
-            if word not in banned_words:
-                return word
+class Solution:
+    def mostCommonWord(self, paragraph: str, banned: List[str]) -> str:
+        s = set(banned)
+        p = Counter(re.findall('[a-z]+', paragraph.lower()))
+        return next(word for word, _ in p.most_common() if word not in s)