Mutating counts without cleanup
Wrong move: Zero-count keys stay in map and break distinct/count constraints.
Usually fails on: Window/map size checks are consistently off by one.
Fix: Delete keys when count reaches zero.
Build confidence with an intuition-first walkthrough focused on hash map fundamentals.
A sentence is a string of single-space separated words where each word consists only of lowercase letters.
A word is uncommon if it appears exactly once in one of the sentences, and does not appear in the other sentence.
Given two sentences s1 and s2, return a list of all the uncommon words. You may return the answer in any order.
Example 1:
Input: s1 = "this apple is sweet", s2 = "this apple is sour"
Output: ["sweet","sour"]
Explanation:
The word "sweet" appears only in s1, while the word "sour" appears only in s2.
Example 2:
Input: s1 = "apple apple", s2 = "banana"
Output: ["banana"]
Constraints:
1 <= s1.length, s2.length <= 200s1 and s2 consist of lowercase English letters and spaces.s1 and s2 do not have leading or trailing spaces.s1 and s2 are separated by a single space.Problem summary: A sentence is a string of single-space separated words where each word consists only of lowercase letters. A word is uncommon if it appears exactly once in one of the sentences, and does not appear in the other sentence. Given two sentences s1 and s2, return a list of all the uncommon words. You may return the answer in any order.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: Hash Map
"this apple is sweet" "this apple is sour"
"apple apple" "banana"
count-common-words-with-one-occurrence)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #884: Uncommon Words from Two Sentences
class Solution {
public String[] uncommonFromSentences(String s1, String s2) {
Map<String, Integer> cnt = new HashMap<>();
for (String s : s1.split(" ")) {
cnt.merge(s, 1, Integer::sum);
}
for (String s : s2.split(" ")) {
cnt.merge(s, 1, Integer::sum);
}
List<String> ans = new ArrayList<>();
for (var e : cnt.entrySet()) {
if (e.getValue() == 1) {
ans.add(e.getKey());
}
}
return ans.toArray(new String[0]);
}
}
// Accepted solution for LeetCode #884: Uncommon Words from Two Sentences
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
}
# Accepted solution for LeetCode #884: Uncommon Words from Two Sentences
class Solution:
def uncommonFromSentences(self, s1: str, s2: str) -> List[str]:
cnt = Counter(s1.split()) + Counter(s2.split())
return [s for s, v in cnt.items() if v == 1]
// Accepted solution for LeetCode #884: Uncommon Words from Two Sentences
use std::collections::HashMap;
impl Solution {
pub fn uncommon_from_sentences(s1: String, s2: String) -> Vec<String> {
let mut map = HashMap::new();
for s in s1.split(' ') {
map.insert(s, !map.contains_key(s));
}
for s in s2.split(' ') {
map.insert(s, !map.contains_key(s));
}
let mut res = Vec::new();
for (k, v) in map {
if v {
res.push(String::from(k));
}
}
res
}
}
// Accepted solution for LeetCode #884: Uncommon Words from Two Sentences
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;
}
Use this to step through a reusable interview workflow for this problem.
For each element, scan the rest of the array looking for a match. Two nested loops give n × (n−1)/2 comparisons = O(n²). No extra space since we only use loop indices.
One pass through the input, performing O(1) hash map lookups and insertions at each step. The hash map may store up to n entries in the worst case. This is the classic space-for-time tradeoff: O(n) extra memory eliminates an inner loop.
Review these before coding to avoid predictable interview regressions.
Wrong move: Zero-count keys stay in map and break distinct/count constraints.
Usually fails on: Window/map size checks are consistently off by one.
Fix: Delete keys when count reaches zero.