Uncommon Words from Two Sentences

class Solution {
public:
    vector<string> uniqueWords(string S1, string S2) {
        unordered_map<string, int> wordFreq;
        stringstream stream1(S1), stream2(S2);
        string token;
    
        while (stream1 >> token) {
            wordFreq[token]++;
        }
    
        while (stream2 >> token) {
            wordFreq[token]++;
        }
    
        vector<string> uniqueTerms;
        for (const auto& entry : wordFreq) {
            if (entry.second == 1) {
                uniqueTerms.push_back(entry.first);
            }
        }
    
        return uniqueTerms;
    }
};

The provided C++ code defines a solution class method uniqueWords that identifies uncommon words between two given sentences, S1 and S2. This method accomplishes the task using the following steps:

1. Create an unordered_map named wordFreq to record the frequency of each word across both sentences.
2. Use a stringstream to parse each word in S1 and increment its count in wordFreq.
3. Similar to the previous step, parse each word in S2 using another stringstream and update the frequency in wordFreq.
4. A vector<string> named uniqueTerms is prepared to store the result.
5. Iterate through each entry in wordFreq. If a word's frequency is exactly one, it is identified as unique and added to uniqueTerms.
6. Finally, uniqueTerms is returned, which contains all the words that appear exactly once in either S1 or S2.

Ensure to include the following steps in the implementation to use this code effectively:

• Include necessary headers such as <vector>, <string>, <sstream>, and <unordered_map> before initializing the solution.
• Prepare two strings representing your sentences to be compared.
• Instantiate the solution and call the uniqueWords method with the sentences to get the list of uncommon words.

class Solution {
    
    public String[] uniqueWords(String sentence1, String sentence2) {
        Map<String, Integer> wordFreq = new HashMap<>();
        for (String word : sentence1.split(" ")) {
            wordFreq.put(word, wordFreq.getOrDefault(word, 0) + 1);
        }
        for (String word : sentence2.split(" ")) {
            wordFreq.put(word, wordFreq.getOrDefault(word, 0) + 1);
        }
    
        List<String> output = new ArrayList<>();
        for (String word : wordFreq.keySet()) {
            if (wordFreq.get(word) == 1) output.add(word);
        }
    
        return output.toArray(new String[0]);
    }
}

The problem "Uncommon Words from Two Sentences" is efficiently addressed using Java in the provided solution. This code defines a method uniqueWords inside the Solution class to identify words that appear exclusively in either of two sentences. The implementation approach involves several key steps:

• Initialize a HashMap named wordFreq to keep track of the frequency of each word from both sentences.
• Split sentence1 into words and update their counts in the wordFreq HashMap using a loop.
• Similarly, repeat the process for sentence2.
• Prepare a list named output to collect words that appear exactly once in either of the sentences.
• Iterate over the keys in wordFreq and check the frequency of each word. If it is exactly one, add that word to the output list.
• Finally, convert the list of uncommon words into an array before returning.

The solution efficiently counts and filters words using straightforward operations on data structures provided by Java’s standard library. This ensures that the method returns an array of uncommon words successfully.

class Solution:
    def findUncommonWords(self, sentence1: str, sentence2: str) -> List[str]:
        from collections import defaultdict
    
        word_count = defaultdict(int)
    
        for word in sentence1.split():
            word_count[word] += 1
    
        for word in sentence2.split():
            word_count[word] += 1
    
        return [word for word in word_count if word_count[word] == 1]

The challenge resolves finding words that appear exclusively in one of two given sentences using Python 3. The solution employs the defaultdict class from the collections module to effectively count occurrences of each word across both sentences.

Follow these steps to understand the solution provided:

1. Import defaultdict from the collections module to facilitate easy counting of word frequencies.

2. Initialize word_count as a defaultdict with integer default values to store and count occurrences of each word from both sentences.

3. Split sentence1 into individual words and iterate over them. Increment the count of each word in word_count.

4. Repeat the process for sentence2, again updating the counts in word_count.

5. Extract and return words from word_count that have a count of exactly one, indicating the word is unique to one sentence and does not appear in the other.

This solution extracts uncommon words efficiently by utilizing a hash map structure allowing for rapid counting and retrieval operations. This process ensures that only words unique to one sentence are included in the final output.