Count Common Words With One Occurrence

• Initialize a counter commonCount to 0.
• Create a HashSet called processed to store words from words1 that have already been checked to avoid redundant work.
• Loop through each word in words1:
  • If word is already in processed, skip to the next iteration.
  • Add word to the processed set.
  • Initialize count1 = 0 to count the frequency of word in words1.
  • Loop through words1 again to count occurrences of word and update count1.
  • If count1 is exactly 1, then proceed to check in words2.
  • Initialize count2 = 0 to count the frequency of word in words2.
  • Loop through words2 to count occurrences of word and update count2.
  • If count2 is also exactly 1, it means the word appears once in both arrays. Increment commonCount.
• After the loops complete, return commonCount.

The brute-force method directly translates the problem's conditions into nested loops. We iterate through each word in the first list, words1. To ensure we only consider each unique word once, we use a Set to keep track of words we've already analyzed. For a given word, we first count its occurrences in words1. If the count isn't one, we move on. If it is one, we then proceed to count its occurrences in words2. If that count is also one, we've found a word that satisfies the condition, and we increment our result counter.

1import java.util.HashSet;2import java.util.Set;3 4class Solution {5    public int countWords(String[] words1, String[] words2) {6        int commonCount = 0;7        Set<String> processed = new HashSet<>();8        for (String word1 : words1) {9            if (processed.contains(word1)) {10                continue;11            }12            processed.add(word1);13 14            int count1 = 0;15            for (String w : words1) {16                if (w.equals(word1)) {17                    count1++;18                }19            }20 21            if (count1 == 1) {22                int count2 = 0;23                for (String w : words2) {24                    if (w.equals(word1)) {25                        count2++;26                    }27                }28                if (count2 == 1) {29                    commonCount++;30                }31            }32        }33        return commonCount;34    }35}

• Create a HashMap<String, Integer> named freqMap1.
• Iterate through words1. For each word, update its count in freqMap1.
• Create a second HashMap<String, Integer> named freqMap2.
• Iterate through words2. For each word, update its count in freqMap2.
• Initialize a counter commonCount to 0.
• Iterate through the keys (words) in freqMap1.
• For each word:
  • Check if its frequency in freqMap1 is 1.
  • Check if the same word exists in freqMap2 and its frequency there is also 1.
  • If both conditions are true, increment commonCount.
• Return commonCount.

This optimized approach avoids the costly repeated scanning of the input arrays by pre-processing them. We first create a hash map to store the frequency of each word in words1. Then, we do the same for words2 with a second hash map. This allows us to determine the frequency of any word in O(1) average time.

Once both frequency maps are built, we can iterate through the keys of the first map. For each word, we check if its count is 1 in the first map and also 1 in the second map. If a word satisfies both conditions, we increment our final counter.

1import java.util.HashMap;2import java.util.Map;3 4class Solution {5    public int countWords(String[] words1, String[] words2) {6        Map<String, Integer> freq1 = new HashMap<>();7        for (String word : words1) {8            freq1.put(word, freq1.getOrDefault(word, 0) + 1);9        }10 11        Map<String, Integer> freq2 = new HashMap<>();12        for (String word : words2) {13            freq2.put(word, freq2.getOrDefault(word, 0) + 1);14        }15 16        int count = 0;17        for (String word : freq1.keySet()) {18            if (freq1.get(word) == 1 && freq2.getOrDefault(word, 0) == 1) {19                count++;20            }21        }22        return count;23    }24}