Uncommon Words from Two Sentences solution and explanation

def uncommonFromSentences(s1, s2):
    from collections import Counter
    count1 = Counter(s1.split())
    count2 = Counter(s2.split())
    result = []
    
    for word in count1:
        if count1[word] == 1 and word not in count2:
            result.append(word)
    for word in count2:
        if count2[word] == 1 and word not in count1:
            result.append(word)
    
    return result

function uncommonFromSentences(s1, s2) {
    const countWords = (sentence) => {
        const words = sentence.split(' ');
        const map = {};
        for (const word of words) {
            map[word] = (map[word] || 0) + 1;
        }
        return map;
    };
    
    const count1 = countWords(s1);
    const count2 = countWords(s2);
    const result = [];

    for (const word in count1) {
        if (count1[word] === 1 && !count2[word]) {
            result.push(word);
        }
    }
    for (const word in count2) {
        if (count2[word] === 1 && !count1[word]) {
            result.push(word);
        }
    }

    return result;
}

import java.util.*;

public class Solution {
    public List<String> uncommonFromSentences(String s1, String s2) {
        Map<String, Integer> count = new HashMap<>();
        String[] words = (s1 + " " + s2).split(" ");
        
        for (String word : words) {
            count.put(word, count.getOrDefault(word, 0) + 1);
        }

        List<String> result = new ArrayList<>();
        for (String word : count.keySet()) {
            if (count.get(word) == 1) {
                result.add(word);
            }
        }

        return result;
    }
}

#include <unordered_map>
#include <vector>
#include <string>
#include <sstream>
using namespace std;

vector<string> uncommonFromSentences(string s1, string s2) {
    unordered_map<string, int> wordCount;
    istringstream stream(s1 + " " + s2);
    string word;
    while (stream >> word) {
        wordCount[word]++;
    }
    vector<string> result;
    for (auto &entry : wordCount) {
        if (entry.second == 1) {
            result.push_back(entry.first);
        }
    }
    return result;
}

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;
}

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
}

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
    }
}