Find the Most Common Response

• Create a master HashSet called allUniqueResponses.
• Iterate through each day's responses[i] and add all strings to allUniqueResponses. This gives us a set of every unique response that exists in the entire dataset.
• Initialize a HashMap<String, Integer> counts to store the frequency of each unique response.
• Iterate through each response in allUniqueResponses.
• For each response, iterate through all the days from i = 0 to responses.length - 1.
• Inside the day loop, create a temporary HashSet from responses[i] to handle duplicates for that specific day.
• Check if the current response is present in the temporary HashSet. If it is, increment its count in the counts map.
• After populating the counts map, iterate through its entries to find the response with the highest frequency.
• Maintain a result string and a maxFreq integer. Update them based on the frequency and lexicographical order for ties.
• Return the final result.

The core idea is to first find the complete dictionary of possible responses and then count the occurrences for each.

• Step 1: Collect All Unique Words: We iterate through the entire 2D array and add every single response to a HashSet. This gives us a set of all unique words that appear anywhere in the survey.

• Step 2: Count Frequencies: We then iterate through our set of unique words. For each word, we start a counter at zero. We then loop through all the days again. For each day, we create another HashSet of that day's responses (to handle duplicates within that day) and check if our target word is present. If it is, we increment our counter. After checking all days, we store the final count in a HashMap.

• Step 3: Find the Winner: After counting is done for all unique words, we iterate through our frequency map to find the word with the highest count, making sure to handle ties by choosing the lexicographically smallest word.

1import java.util.*;2 3class Solution {4    public String mostCommonWord(String[][] responses) {5        Set<String> allUniqueResponses = new HashSet<>();6        for (String[] dayResponses : responses) {7            for (String response : dayResponses) {8                allUniqueResponses.add(response);9            }10        }11 12        Map<String, Integer> counts = new HashMap<>();13        for (String uniqueResponse : allUniqueResponses) {14            int currentCount = 0;15            for (String[] dayResponses : responses) {16                Set<String> dailyUnique = new HashSet<>(Arrays.asList(dayResponses));17                if (dailyUnique.contains(uniqueResponse)) {18                    currentCount++;19                }20            }21            counts.put(uniqueResponse, currentCount);22        }23 24        String mostCommon = "";25        int maxFreq = -1;26 27        for (Map.Entry<String, Integer> entry : counts.entrySet()) {28            String response = entry.getKey();29            int freq = entry.getValue();30            if (freq > maxFreq) {31                maxFreq = freq;32                mostCommon = response;33            } else if (freq == maxFreq) {34                if (mostCommon.isEmpty() || response.compareTo(mostCommon) < 0) {35                    mostCommon = response;36                }37            }38        }39 40        return mostCommon;41    }42}

• Initialize a HashMap<String, Integer> counts to store frequencies.
• Initialize result = "" and maxFreq = 0 to track the winner in real-time.
• Iterate through each day's responses dayResponses in the input responses.
• For each dayResponses, create a HashSet<String> to get the unique responses for that day. This efficiently handles the duplicate removal requirement for each day.
• Iterate through the unique responses from the daily HashSet.
• For each unique response, increment its count in the global counts map and get its newFreq.
• Compare newFreq with maxFreq:
  • If newFreq > maxFreq, a new most common word is found. Update maxFreq = newFreq and result = response.
  • If newFreq == maxFreq, there is a tie. Check if the current response is lexicographically smaller than the current result. If so, update result.
• After iterating through all days, result will hold the correct answer.

This method processes the data in a single pass, which is much more efficient. Instead of finding all unique words first, we count them as we encounter them.

• Step 1: Initialize Data Structures: We need a HashMap<String, Integer> to store the frequency of each response. We also initialize variables result and maxFreq to keep track of the most common response found so far.

• Step 2: Process Day by Day: We loop through each day's list of responses. For each day, we first put its responses into a HashSet. This is a quick way to get only the unique responses for that day.

• Step 3: Update Counts and Track Winner: We then iterate through this set of unique daily responses. For each response, we update its count in our main HashMap. Immediately after updating a count, we check if this response has become the new winner.

  • We compare its new frequency with maxFreq. If it's greater, this response becomes the new result.
  • If the frequency is equal to maxFreq, we resolve the tie by comparing it lexicographically with the current result and updating if the new response is smaller.

This way, when the loops are finished, we have our final answer without needing a separate step to find the winner.

1import java.util.*;2 3class Solution {4    public String mostCommonWord(String[][] responses) {5        Map<String, Integer> counts = new HashMap<>();6        String result = "";7        int maxFreq = 0;8 9        for (String[] dayResponses : responses) {10            Set<String> uniqueDailyResponses = new HashSet<>(Arrays.asList(dayResponses));11            for (String response : uniqueDailyResponses) {12                int newFreq = counts.getOrDefault(response, 0) + 1;13                counts.put(response, newFreq);14 15                if (newFreq > maxFreq) {16                    maxFreq = newFreq;17                    result = response;18                } else if (newFreq == maxFreq) {19                    if (response.compareTo(result) < 0) {20                        result = response;21                    }22                }23            }24        }25        return result;26    }27}