Find the Most Common Response - Practice Coding Problems

Find the Most Common Response - Problem

You're analyzing survey data collected over multiple days to identify the most popular response across all participants. Given a 2D string array responses where each responses[i] represents survey responses collected on the i-th day, your task is to find the most frequently occurring response.

Important: Remove duplicate responses within each day before counting (a person can only vote once per day), but the same response can appear on different days.

If there's a tie between multiple responses with the same frequency, return the lexicographically smallest response (alphabetically first).

Example: If Day 1 has ["yes", "no", "yes"] and Day 2 has ["no", "maybe"], after removing duplicates we get ["yes", "no"] and ["no", "maybe"]. The response "no" appears 2 times total, making it the most common.

Input & Output

example_1.py — Basic Case

$ Input: responses = [["yes", "no", "yes"], ["no", "maybe"], ["yes", "no"]]

› Output: "no"

💡 Note: After removing duplicates within each day: Day 1: {"yes", "no"}, Day 2: {"no", "maybe"}, Day 3: {"yes", "no"}. Counting frequencies: "yes" appears 2 times, "no" appears 3 times, "maybe" appears 1 time. "no" has the highest frequency.

example_2.py — Lexicographic Tie

$ Input: responses = [["apple", "banana"], ["banana", "apple"], ["cherry"]]

› Output: "apple"

💡 Note: After removing duplicates: Day 1: {"apple", "banana"}, Day 2: {"banana", "apple"}, Day 3: {"cherry"}. Frequencies: "apple": 2, "banana": 2, "cherry": 1. "apple" and "banana" tie with 2 occurrences each, but "apple" is lexicographically smaller.

example_3.py — Single Day

$ Input: responses = [["vote", "vote", "abstain", "vote"]]

› Output: "abstain"

💡 Note: Only one day with responses. After removing duplicates: {"vote", "abstain"}. Both appear once in the deduplicated day, but "abstain" is lexicographically smaller than "vote".

Visualization

Tap to expand

Understanding the Visualization

Daily Deduplication

Remove duplicate responses within each day (one vote per person per day)

Frequency Counting

Count how many days each unique response appears

Find Winner

Select response with highest frequency (lexicographically smallest for ties)

Key Takeaway

🎯 Key Insight: Use sets for efficient daily deduplication and hash tables for frequency counting - this gives us O(n*m) optimal performance while handling all edge cases including lexicographic tie-breaking.

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

n days and m average responses per day - each response is processed exactly once

✓ Linear Growth

Space Complexity

O(k)

k is the number of unique responses across all days for the frequency hash map

✓ Linear Space

Constraints

1 ≤ responses.length ≤ 100
1 ≤ responses[i].length ≤ 100
1 ≤ responses[i][j].length ≤ 10
responses[i][j] consists of lowercase English letters only
Each day has at least one response

Asked in

G Google 35 a Amazon 28 f Meta 22 ⊞ Microsoft 18

The optimal solution uses a hash table with set-based deduplication to efficiently count response frequencies. For each day, convert responses to a set to eliminate duplicates, then update the global frequency counter. Finally, find the response with maximum count, choosing the lexicographically smallest in case of ties. Time complexity: O(n*m), Space complexity: O(k) where k is unique responses.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n * m)	O(k)	Use hash map to count responses while removing duplicates in a single pass
Brute Force (Nested Loops)	O(n * m * k)	O(k)	Manually remove duplicates and count each response across all days

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize a hash map to store response frequencies
For each day's responses, convert to a set to remove duplicates
For each unique response in the day, increment its count in the hash map
After processing all days, find the response with maximum count (lexicographically smallest for ties)

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Hash Map

Create frequency counter for all responses

Process Each Day

Convert day responses to set, removing duplicates

Update Frequencies

Increment count for each unique response in the day

Find Maximum

Scan hash map once to find most frequent response

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

// Simple hash table implementation would be needed for C
char* findMostCommonResponse(char*** responses, int numDays, int* dayLengths) {
    // Implementation would require custom hash table
    char* result = (char*)malloc(100 * sizeof(char));
    strcpy(result, "implementation_needed");
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

n days and m average responses per day - each response is processed exactly once

✓ Linear Growth

Space Complexity

O(k)

k is the number of unique responses across all days for the frequency hash map

✓ Linear Space

Constraints

1 ≤ responses.length ≤ 100
1 ≤ responses[i].length ≤ 100
1 ≤ responses[i][j].length ≤ 10
responses[i][j] consists of lowercase English letters only
Each day has at least one response

28.3K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler