Find Common Characters - Practice Coding Problems

Find Common Characters - Problem

Given a string array words, return an array of all characters that show up in all strings within the words (including duplicates). You may return the answer in any order.

For example, if a character occurs 3 times in each string and 2 times in another string, you should include that character 2 times in the final answer (the minimum occurrence across all strings).

Input & Output

Example 1 — Basic Case

$ Input: words = ["bella","label","roller"]

› Output: ["e","l","l"]

💡 Note: Character 'e' appears once in each word, 'l' appears twice in each word, so result is ["e", "l", "l"]

Example 2 — Different Frequencies

$ Input: words = ["cool","lock","cook"]

› Output: ["c","o"]

💡 Note: Character 'c' appears once in each word, 'o' appears twice in 'cool' and 'cook' but once in 'lock', so we take minimum count of 1

Example 3 — No Common Characters

$ Input: words = ["abc","def","ghi"]

› Output: []

💡 Note: No characters appear in all three words, so result is empty array

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
words[i] consists of lowercase English letters.

Visualization

Tap to expand

Understanding the Visualization

Input Analysis

Array of strings with various characters

Find Common

Identify characters present in every string

Minimum Count

Take minimum frequency across all strings

Key Takeaway

🎯 Key Insight: The result is limited by whichever string has the fewest occurrences of each character

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is that we need to find the minimum frequency of each character across all strings. The best approach is frequency counting - build frequency maps for each string, then for each character that appears in all strings, take the minimum count. Time: O(n × m), Space: O(n × k).

Common Approaches

Approach	Time	Space	Notes
✓ Frequency Counting	O(n × m)	O(n × k)	Count character frequencies in each string and find minimum occurrences
Brute Force Character Check	O(n × m²)	O(n × m)	Check each character of first string against all other strings one by one

Frequency Counting — Algorithm Steps

Create frequency map for each string
Find characters that exist in all maps
For each common character, take minimum frequency across all strings

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Build frequency map for each string

Find Minimums

For each character, find minimum count across all strings

Build Result

Add each character minimum times to result

Code -

solution.c — C

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

char** solution(char** words, int wordsSize, int* returnSize) {
    *returnSize = 0;
    if (wordsSize == 0) return NULL;
    
    // Use arrays to count character frequencies (a-z)
    int counters[wordsSize][26];
    memset(counters, 0, sizeof(counters));
    
    // Count characters in each word
    for (int i = 0; i < wordsSize; i++) {
        for (int j = 0; j < strlen(words[i]); j++) {
            counters[i][words[i][j] - 'a']++;
        }
    }
    
    char** result = malloc(1000 * sizeof(char*));
    
    // For each character in first word (check unique characters)
    int processed[26] = {0};
    for (int pos = 0; pos < strlen(words[0]); pos++) {
        int charIndex = words[0][pos] - 'a';
        if (processed[charIndex]) continue;
        processed[charIndex] = 1;
        
        // Find minimum count across all words
        int minCount = counters[0][charIndex];
        for (int i = 1; i < wordsSize; i++) {
            if (counters[i][charIndex] < minCount) {
                minCount = counters[i][charIndex];
            }
        }
        
        // Add character minCount times to result
        for (int i = 0; i < minCount; i++) {
            result[*returnSize] = malloc(2);
            result[*returnSize][0] = words[0][pos];
            result[*returnSize][1] = '\0';
            (*returnSize)++;
        }
    }
    
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char** words = malloc(100 * sizeof(char*));
    int wordsSize = 0;
    
    char* token = strtok(line, "\"");
    while (token != NULL) {
        if (strlen(token) > 2 && token[0] != '[' && token[0] != ']' && token[0] != ',') {
            words[wordsSize] = malloc(strlen(token) + 1);
            strcpy(words[wordsSize], token);
            wordsSize++;
        }
        token = strtok(NULL, "\"");
    }
    
    int returnSize;
    char** result = solution(words, wordsSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

Iterate through all characters in all strings once to build frequency maps, then iterate through first string's characters

✓ Linear Growth

Space Complexity

O(n × k)

Store frequency maps for n strings, each with at most k unique characters

⚡ Linearithmic Space

28.5K 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

Constraints

Visualization

Related Problems

Common Approaches

Frequency Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler