Find Common Characters - Practice Coding Problems

Find Common Characters - Problem

Find Common Characters

Given an array of strings words, your task is to find all characters that appear in every single string. The catch? You need to include duplicates! If a character appears twice in every string, it should appear twice in your result.

Goal: Return an array containing all characters that show up in all strings within the words array (including duplicates).

Example: If you have ["bella", "label", "roller"], the characters that appear in all three strings are ['e', 'l', 'l']. Notice how 'l' appears twice because it appears at least twice in each string.

You may return the answer in any order.

Input & Output

example_1.py — Basic case with common characters

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

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

💡 Note: 'e' appears once in all words. 'l' appears at least twice in all words, so we include it twice. 'b' and 'a' don't appear in 'roller', and 'r', 'o' don't appear in other words.

example_2.py — No common characters

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

› Output: []

💡 Note: No character appears in all three words, so the result is an empty array.

example_3.py — Single word case

$ Input: ["hello"]

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

💡 Note: With only one word, all characters in that word are 'common' to all words in the array. The 'l' appears twice, so it's included twice in the result.

Visualization

Tap to expand

Understanding the Visualization

Start with first recipe

bella: b(1), e(1), l(2), a(1) - this gives us our initial 'shopping list'

Check second recipe

label: l(2), a(1), b(1), e(1) - all ingredients still available, quantities unchanged

Check third recipe

roller: r(2), o(1), l(2), e(1) - b and a are missing! Update our list

Final shopping list

Only e(1) and l(2) survived all recipes - these are our common characters

Key Takeaway

🎯 Key Insight: The frequency of any common character is limited by the word that contains the fewest occurrences of that character. Using a hash table to track minimum counts across all words gives us an optimal O(n×m) solution.

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n words each with m characters, but we process optimally in one pass

✓ Linear Growth

Space Complexity

O(k)

Only one frequency map storing k unique characters from first word

✓ Linear Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
words[i] consists of lowercase English letters only
Important: Duplicates matter - if a character appears multiple times in every word, include it multiple times in the result

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 Apple 28

The optimal solution uses a one-pass hash table approach. Initialize character counts with the first word, then for each subsequent word, update the counts to keep only the minimum occurrences of each character. This ensures we only keep characters that appear in ALL words, with the correct frequency. Time complexity: O(n×m), Space complexity: O(k) where k is the number of unique characters.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table (Count Then Compare)	O(n × m)	O(n × k)	First count character frequencies in each word, then find minimum counts
One-Pass Hash Table (Optimal)	O(n × m)	O(k)	Initialize with first word's counts, then update minimums in one pass
Brute Force (Character by Character)	O(n × m × k)	O(1)	Check each character from first string against all other strings

Two-Pass Hash Table (Count Then Compare) — Algorithm Steps

Create frequency maps for each word
For each character in the first word, find its minimum frequency across all words
Add that many copies of the character to the result
Return the result array

Visualization

Tap to expand

Step-by-Step Walkthrough

Count frequencies

Build hash maps for each word: bella{b:1,e:1,l:2,a:1}, label{l:2,a:1,b:1,e:1}, roller{r:2,o:1,l:2,e:1}

Find minimums

For each character in first word, find minimum count across all words

Build result

Add characters to result based on minimum counts: e(1), l(2)

Code -

solution.c — C

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

#define MAX_CHARS 26

char** commonChars(char** words, int wordsSize, int* returnSize) {
    *returnSize = 0;
    if (wordsSize == 0) return NULL;
    
    // First pass: count characters in each word
    int wordCounts[wordsSize][MAX_CHARS];
    memset(wordCounts, 0, sizeof(wordCounts));
    
    for (int i = 0; i < wordsSize; i++) {
        for (int j = 0; words[i][j] != '\0'; j++) {
            wordCounts[i][words[i][j] - 'a']++;
        }
    }
    
    char** result = malloc(1000 * sizeof(char*));
    
    // Second pass: find minimum count for each character
    for (int c = 0; c < MAX_CHARS; c++) {
        if (wordCounts[0][c] > 0) {
            int minCount = wordCounts[0][c];
            
            for (int i = 1; i < wordsSize; i++) {
                if (wordCounts[i][c] < minCount) {
                    minCount = wordCounts[i][c];
                }
            }
            
            for (int i = 0; i < minCount; i++) {
                result[*returnSize] = malloc(2 * sizeof(char));
                result[*returnSize][0] = 'a' + c;
                result[*returnSize][1] = '\0';
                (*returnSize)++;
            }
        }
    }
    
    return result;
}

int main() {
    char* words[] = {"bella", "label", "roller"};
    int returnSize;
    char** result = commonChars(words, 3, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

n words each with m characters on average, we process each character once per word

✓ Linear Growth

Space Complexity

O(n × k)

n frequency maps, each storing up to k unique characters

⚡ Linearithmic Space

Constraints

1 ≤ words.length ≤ 100
1 ≤ words[i].length ≤ 100
words[i] consists of lowercase English letters only
Important: Duplicates matter - if a character appears multiple times in every word, include it multiple times in the result

52.0K Views

Medium Frequency

~15 min Avg. Time

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

Two-Pass Hash Table (Count Then Compare) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler