Find Common Characters — Editorial

Opening the reading…

Intuitionwhy every shared copy is a minimum

A character belongs in the answer once for each copy that every word can provide. If one word has three l characters and another has only two, only two copies can be common. Therefore the number of common copies of each letter is the minimum frequency of that letter across all words.

You only need 26 counters because every character is a lowercase English letter. Count one word at a time, and for each letter keep the smallest count seen so far. After all words are processed, a minimum of zero means the letter is absent from at least one word, while a larger minimum tells you exactly how many strings to append.

Approach

Create minFreq with 26 entries set to INT_MAX, because the first word's counts must replace an unconstrained initial value rather than be limited by zero.

For each word, create a fresh frequency array of 26 zeros and count every character, because counts from different words must not leak into one another.

Compare the current word's count for every letter with minFreq and keep the smaller value, because a character can be used commonly only as many times as its least frequent word allows.

After all words have updated minFreq, scan the 26 letters in order, because each positive minimum represents that many copies in the answer.

Append a one-character string while the letter's minimum is positive, decrementing the stored count each time so duplicate common characters are preserved instead of being returned only once.

Return the result; its order is valid because the problem accepts any order, and alphabetical scanning is a simple deterministic choice.

Complexitythe alphabet is fixed, but every input character is still counted

MEASURE	BOUND	WHY
Time	O(S + 26W)	Each input character increments exactly one frequency counter. For each of the W words, the algorithm then checks all 26 letters once, and the final output scan checks those 26 letters once more; no character is rescanned beyond these passes.
Space	O(26) = O(1) extra space	Each word uses one 26-entry temporary array and the running minimum uses another, so the working memory stays fixed regardless of input length. The returned result is required output and is excluded; its size can be as large as the shortest word in the worst case.

W is the number of words and S is the total number of characters across all words. The alphabet size is the fixed constant 26.

Annotated solutionC++ · frequency minima · complete judge-ready implementation

CPPCount each word, take per-letter minima, then emit every surviving copy.

#include <algorithm>
#include <climits>
#include <string>
#include <vector>

using namespace std;

class Solution {
public:
    vector<string> commonChars(vector<string>& words) {
        vector<int> minFreq(26, INT_MAX);

        for (const string& word : words) {
            vector<int> freq(26, 0);
            for (char c : word) {
                freq[c - 'a']++;
            }

            for (int i = 0; i < 26; i++) {
                minFreq[i] = min(minFreq[i], freq[i]);
            }
        }

        vector<string> result;
        for (int i = 0; i < 26; i++) {
            while (minFreq[i]-- > 0) {
                result.push_back(string(1, 'a' + i));
            }
        }

        return result;
    }
};

The fresh freq array inside the word loop is essential: it describes only the current word. The min operation then combines that isolated count with the best count all previous words could guarantee. At the end, the while loop is deliberately not an if statement; a minimum of two means two separate copies must be added to the result.