Find the Most Common Response

Find the Most Common Response - Problem

You are given a 2D string array responses where each responses[i] is an array of strings representing survey responses from the i-th day.

Return the most common response across all days after removing duplicate responses within each responses[i].

If there is a tie, return the lexicographically smallest response.

Input & Output

Example 1 — Basic Deduplication and Counting

$ Input: responses = [["happy","sad","happy"],["sad","angry"]]

› Output: "sad"

💡 Note: Day 1 unique responses: {happy, sad}. Day 2 unique responses: {sad, angry}. Total counts: happy=1, sad=2, angry=1. Most frequent is 'sad' with count 2.

Example 2 — Lexicographic Tie-Breaking

$ Input: responses = [["a","b"],["b","c"]]

› Output: "b"

💡 Note: Day 1 unique responses: {a, b}. Day 2 unique responses: {b, c}. Total counts: a=1, b=2, c=1. Most frequent is 'b' with count 2.

Example 3 — Multiple Days Same Response

$ Input: responses = [["good"],["good","bad"],["good"]]

› Output: "good"

💡 Note: After deduplication per day: Day 1: {good}, Day 2: {good, bad}, Day 3: {good}. Counts: good=3, bad=1. Most frequent is 'good'.

Constraints

1 ≤ responses.length ≤ 100
1 ≤ responses[i].length ≤ 100
1 ≤ responses[i][j].length ≤ 100
responses[i][j] consists of lowercase English letters only

Visualization

Tap to expand

Asked in

a Amazon 35 G Google 28 M Microsoft 22 f Facebook 18

The key insight is to first remove duplicates within each day using sets, then count frequencies across all days. The optimal approach uses a hash map for O(1) frequency updates, achieving O(n) time complexity where n is the total number of responses.

Common Approaches

✓ Brute Force with Nested Loops

⏱️ Time: O(n²) Space: O(n)

For each day, create a set to remove duplicates. Then use nested loops to count each unique response across all days and find the most frequent one.

Hash Map Frequency Counting

⏱️ Time: O(n) Space: O(n)

First remove duplicates within each day using sets, then use a hash map to count the frequency of each unique response across all days. Finally find the most frequent response with lexicographic tie-breaking.

Brute Force with Nested Loops — Algorithm Steps

Step 1: For each day, convert responses to set to remove duplicates
Step 2: Use nested loops to count frequency of each response
Step 3: Find response with maximum count, break ties lexicographically

Visualization

Tap to expand

Step-by-Step Walkthrough

Remove Duplicates Per Day

Convert each day's responses to set

Manual Counting

Use nested loops to count each response

Find Maximum

Track max count and lexicographically smallest

Code -

solution.c — C

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

#define MAX_RESPONSES 1000
#define MAX_DAYS 100
#define MAX_WORD_LEN 100

typedef struct {
    char word[MAX_WORD_LEN];
    int count;
} ResponseCount;

int isDuplicate(char responses[][MAX_WORD_LEN], int count, char* word) {
    for (int i = 0; i < count; i++) {
        if (strcmp(responses[i], word) == 0) {
            return 1;
        }
    }
    return 0;
}

int findOrAddResponse(ResponseCount* counts, int* totalCount, char* word) {
    for (int i = 0; i < *totalCount; i++) {
        if (strcmp(counts[i].word, word) == 0) {
            counts[i].count++;
            return i;
        }
    }
    strcpy(counts[*totalCount].word, word);
    counts[*totalCount].count = 1;
    (*totalCount)++;
    return *totalCount - 1;
}

char* findMostCommon(ResponseCount* counts, int totalCount) {
    if (totalCount == 0) return NULL;
    
    int maxCount = counts[0].count;
    char* result = counts[0].word;
    
    for (int i = 1; i < totalCount; i++) {
        if (counts[i].count > maxCount || 
            (counts[i].count == maxCount && strcmp(counts[i].word, result) < 0)) {
            maxCount = counts[i].count;
            result = counts[i].word;
        }
    }
    return result;
}

int main() {
    char input[10000];
    fgets(input, sizeof(input), stdin);
    
    ResponseCount counts[MAX_RESPONSES];
    int totalCount = 0;
    
    char* ptr = input;
    while (*ptr && *ptr != '[') ptr++; // Find first '['
    if (!*ptr) return 1;
    ptr++; // Skip '['
    
    while (*ptr) {
        // Skip whitespace and commas
        while (*ptr && (*ptr == ' ' || *ptr == ',' || *ptr == '\n' || *ptr == '\r')) ptr++;
        
        if (*ptr == ']') break; // End of main array
        
        if (*ptr == '[') { // Start of a day's responses
            ptr++; // Skip '['
            
            char dayResponses[MAX_RESPONSES][MAX_WORD_LEN];
            int dayCount = 0;
            
            while (*ptr && *ptr != ']') {
                // Skip whitespace and commas
                while (*ptr && (*ptr == ' ' || *ptr == ',')) ptr++;
                
                if (*ptr == '"') { // Start of string
                    ptr++; // Skip opening quote
                    char word[MAX_WORD_LEN];
                    int wordLen = 0;
                    
                    while (*ptr && *ptr != '"' && wordLen < MAX_WORD_LEN - 1) {
                        word[wordLen++] = *ptr++;
                    }
                    word[wordLen] = '\0';
                    
                    if (*ptr == '"') ptr++; // Skip closing quote
                    
                    // Add to day responses if not duplicate
                    if (!isDuplicate(dayResponses, dayCount, word)) {
                        strcpy(dayResponses[dayCount], word);
                        dayCount++;
                    }
                }
                
                // Skip to next item or end of day array
                while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
                if (*ptr == ',') ptr++;
            }
            
            if (*ptr == ']') ptr++; // Skip closing ']' of day array
            
            // Add all unique responses from this day to global count
            for (int i = 0; i < dayCount; i++) {
                findOrAddResponse(counts, &totalCount, dayResponses[i]);
            }
        }
        
        // Skip to next day or end
        while (*ptr && *ptr != '[' && *ptr != ']') ptr++;
    }
    
    char* result = findMostCommon(counts, totalCount);
    if (result) {
        printf("%s\n", result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Nested loops to count each response across all unique responses

✓ Linear Growth

Space Complexity

O(n)

Sets to store unique responses per day and overall unique list

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force with Nested Loops — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler