feat: add solutions to lc problem: No.0884

No.0884.Uncommon Words from Two Sentences

Author: yanglbme

solution/0800-0899/0884.Uncommon Words from Two Sentences/README.md

@@ -46,9 +46,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-使用哈希表 `HashMap<String, Integer>` 记录字符串出现的次数，完成所有记录后遍历哈希表，找到出现次数为 1 的 `key`，存入数组当中并返回。
+**方法一：哈希表**
 
-由于只关注出现 1 次的字符串，可以将 `value` 类型定为 `Boolean`。首次记录为 `true`，后续再出现则改为 `false`。
+根据题目描述，只要单词出现一次，就符合题目要求。因此，我们用哈希表 $cnt$ 记录所有单词以及出现的次数。
+
+然后遍历哈希表，取出所有出现次数为 $1$ 的字符串即可。
+
+时间复杂度 $O(m + n)$，空间复杂度 $O(m + n)$。其中 $m$ 和 $n$ 分别是字符串 $s1$ 和 $s2$ 的长度。
 
 <!-- tabs:start -->
 
@@ -59,8 +63,8 @@
 ```python
 class Solution:
     def uncommonFromSentences(self, s1: str, s2: str) -> List[str]:
-        c = Counter(s1.split()) + Counter(s2.split())
-        return [w for w, n in c.items() if n == 1]
+        cnt = Counter(s1.split()) + Counter(s2.split())
+        return [s for s, v in cnt.items() if v == 1]
 ```
 
 ### **Java**
@@ -69,43 +73,22 @@ class Solution:
 
 ```java
 class Solution {
-
     public String[] uncommonFromSentences(String s1, String s2) {
-        Map<String, Integer> counter = new HashMap<>();
-        add(s1, counter);
-        add(s2, counter);
+        Map<String, Integer> cnt = new HashMap<>();
+        for (String s : s1.split(" ")) {
+            cnt.put(s, cnt.getOrDefault(s, 0) + 1);
+        }
+        for (String s : s2.split(" ")) {
+            cnt.put(s, cnt.getOrDefault(s, 0) + 1);
+        }
         List<String> ans = new ArrayList<>();
-        for (Map.Entry<String, Integer> e : counter.entrySet()) {
+        for (var e : cnt.entrySet()) {
             if (e.getValue() == 1) {
                 ans.add(e.getKey());
             }
         }
         return ans.toArray(new String[0]);
     }
-
-    private void add(String s, Map<String, Integer> counter) {
-        for (String w : s.split(" ")) {
-            counter.put(w, counter.getOrDefault(w, 0) + 1);
-        }
-    }
-}
-```
-
-### **TypeScript**
-
-```ts
-function uncommonFromSentences(s1: string, s2: string): string[] {
-    let hashMap: Map<string, number> = new Map();
-    for (let str of [...s1.split(' '), ...s2.split(' ')]) {
-        hashMap.set(str, (hashMap.get(str) || 0) + 1);
-    }
-    let ans: Array<string> = [];
-    for (let [key, count] of hashMap.entries()) {
-        if (count == 1) {
-            ans.push(key);
-        }
-    }
-    return ans;
 }
 ```
 
@@ -115,20 +98,16 @@ function uncommonFromSentences(s1: string, s2: string): string[] {
 class Solution {
 public:
     vector<string> uncommonFromSentences(string s1, string s2) {
-        unordered_map<string, int> counter;
-
-        auto add = [&](const string& s) {
+        unordered_map<string, int> cnt;
+        auto add = [&](string& s) {
             stringstream ss(s);
-            string word;
-            while (ss >> word) ++counter[move(word)];
+            string w;
+            while (ss >> w) ++cnt[move(w)];
         };
-
         add(s1);
         add(s2);
         vector<string> ans;
-        for (auto& [word, n] : counter)
-            if (n == 1)
-                ans.push_back(word);
+        for (auto& [s, v] : cnt) if (v == 1) ans.emplace_back(s);
         return ans;
     }
 };
@@ -137,22 +116,38 @@ public:
 ### **Go**
 
 ```go
-func uncommonFromSentences(s1 string, s2 string) []string {
-	counter := make(map[string]int)
-	add := func(s string) {
-		for _, w := range strings.Split(s, " ") {
-			counter[w]++
-		}
-	}
-	add(s1)
-	add(s2)
-	var ans []string
-	for word, n := range counter {
-		if n == 1 {
-			ans = append(ans, word)
-		}
-	}
-	return ans
+func uncommonFromSentences(s1 string, s2 string) (ans []string) {
+    cnt := map[string]int{}
+    for _, s := range strings.Split(s1, " ") {
+        cnt[s]++
+    }
+    for _, s := range strings.Split(s2, " ") {
+        cnt[s]++
+    }
+    for s, v := range cnt {
+        if v == 1 {
+            ans = append(ans, s)
+        }
+    }
+    return
+}
+```
+
+### **TypeScript**
+
+```ts
+function uncommonFromSentences(s1: string, s2: string): string[] {
+    const cnt: Map<string, number> = new Map();
+    for (const s of [...s1.split(' '), ...s2.split(' ')]) {
+        cnt.set(s, (cnt.get(s) || 0) + 1);
+    }
+    const ans: Array<string> = [];
+    for (const [s, v] of cnt.entries()) {
+        if (v == 1) {
+            ans.push(s);
+        }
+    }
+    return ans;
 }
 ```
 
@@ -181,6 +176,29 @@ impl Solution {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {string[]}
+ */
+var uncommonFromSentences = function (s1, s2) {
+    const cnt = new Map();
+    for (const s of [...s1.split(' '), ...s2.split(' ')]) {
+        cnt.set(s, (cnt.get(s) || 0) + 1);
+    }
+    const ans = [];
+    for (const [s, v] of cnt.entries()) {
+        if (v == 1) {
+            ans.push(s);
+        }
+    }
+    return ans;
+};
+```
+
 ### **...**
 
 ```

solution/0800-0899/0884.Uncommon Words from Two Sentences/README_EN.md

@@ -37,51 +37,30 @@
 ```python
 class Solution:
     def uncommonFromSentences(self, s1: str, s2: str) -> List[str]:
-        c = Counter(s1.split()) + Counter(s2.split())
-        return [w for w, n in c.items() if n == 1]
+        cnt = Counter(s1.split()) + Counter(s2.split())
+        return [s for s, v in cnt.items() if v == 1]
 ```
 
 ### **Java**
 
 ```java
 class Solution {
-
     public String[] uncommonFromSentences(String s1, String s2) {
-        Map<String, Integer> counter = new HashMap<>();
-        add(s1, counter);
-        add(s2, counter);
+        Map<String, Integer> cnt = new HashMap<>();
+        for (String s : s1.split(" ")) {
+            cnt.put(s, cnt.getOrDefault(s, 0) + 1);
+        }
+        for (String s : s2.split(" ")) {
+            cnt.put(s, cnt.getOrDefault(s, 0) + 1);
+        }
         List<String> ans = new ArrayList<>();
-        for (Map.Entry<String, Integer> e : counter.entrySet()) {
+        for (var e : cnt.entrySet()) {
             if (e.getValue() == 1) {
                 ans.add(e.getKey());
             }
         }
         return ans.toArray(new String[0]);
     }
-
-    private void add(String s, Map<String, Integer> counter) {
-        for (String w : s.split(" ")) {
-            counter.put(w, counter.getOrDefault(w, 0) + 1);
-        }
-    }
-}
-```
-
-### **TypeScript**
-
-```ts
-function uncommonFromSentences(s1: string, s2: string): string[] {
-    let hashMap: Map<string, number> = new Map();
-    for (let str of [...s1.split(' '), ...s2.split(' ')]) {
-        hashMap.set(str, (hashMap.get(str) || 0) + 1);
-    }
-    let ans: Array<string> = [];
-    for (let [key, count] of hashMap.entries()) {
-        if (count == 1) {
-            ans.push(key);
-        }
-    }
-    return ans;
 }
 ```
 
@@ -91,20 +70,16 @@ function uncommonFromSentences(s1: string, s2: string): string[] {
 class Solution {
 public:
     vector<string> uncommonFromSentences(string s1, string s2) {
-        unordered_map<string, int> counter;
-
-        auto add = [&](const string& s) {
+        unordered_map<string, int> cnt;
+        auto add = [&](string& s) {
             stringstream ss(s);
-            string word;
-            while (ss >> word) ++counter[move(word)];
+            string w;
+            while (ss >> w) ++cnt[move(w)];
         };
-
         add(s1);
         add(s2);
         vector<string> ans;
-        for (auto& [word, n] : counter)
-            if (n == 1)
-                ans.push_back(word);
+        for (auto& [s, v] : cnt) if (v == 1) ans.emplace_back(s);
         return ans;
     }
 };
@@ -113,22 +88,38 @@ public:
 ### **Go**
 
 ```go
-func uncommonFromSentences(s1 string, s2 string) []string {
-	counter := make(map[string]int)
-	add := func(s string) {
-		for _, w := range strings.Split(s, " ") {
-			counter[w]++
-		}
-	}
-	add(s1)
-	add(s2)
-	var ans []string
-	for word, n := range counter {
-		if n == 1 {
-			ans = append(ans, word)
-		}
-	}
-	return ans
+func uncommonFromSentences(s1 string, s2 string) (ans []string) {
+    cnt := map[string]int{}
+    for _, s := range strings.Split(s1, " ") {
+        cnt[s]++
+    }
+    for _, s := range strings.Split(s2, " ") {
+        cnt[s]++
+    }
+    for s, v := range cnt {
+        if v == 1 {
+            ans = append(ans, s)
+        }
+    }
+    return
+}
+```
+
+### **TypeScript**
+
+```ts
+function uncommonFromSentences(s1: string, s2: string): string[] {
+    const cnt: Map<string, number> = new Map();
+    for (const s of [...s1.split(' '), ...s2.split(' ')]) {
+        cnt.set(s, (cnt.get(s) || 0) + 1);
+    }
+    const ans: Array<string> = [];
+    for (const [s, v] of cnt.entries()) {
+        if (v == 1) {
+            ans.push(s);
+        }
+    }
+    return ans;
 }
 ```
 
@@ -157,6 +148,29 @@ impl Solution {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {string[]}
+ */
+var uncommonFromSentences = function (s1, s2) {
+    const cnt = new Map();
+    for (const s of [...s1.split(' '), ...s2.split(' ')]) {
+        cnt.set(s, (cnt.get(s) || 0) + 1);
+    }
+    const ans = [];
+    for (const [s, v] of cnt.entries()) {
+        if (v == 1) {
+            ans.push(s);
+        }
+    }
+    return ans;
+};
+```
+
 ### **...**
 
 ```

solution/0800-0899/0884.Uncommon Words from Two Sentences/Solution.cpp

@@ -1,20 +1,16 @@
 class Solution {
 public:
     vector<string> uncommonFromSentences(string s1, string s2) {
-        unordered_map<string, int> counter;
-
-        auto add = [&](const string& s) {
+        unordered_map<string, int> cnt;
+        auto add = [&](string& s) {
             stringstream ss(s);
-            string word;
-            while (ss >> word) ++counter[move(word)];
+            string w;
+            while (ss >> w) ++cnt[move(w)];
         };
-
         add(s1);
         add(s2);
         vector<string> ans;
-        for (auto& [word, n] : counter)
-            if (n == 1)
-                ans.push_back(word);
+        for (auto& [s, v] : cnt) if (v == 1) ans.emplace_back(s);
         return ans;
     }
 };