Check if All Characters Have Equal Number of Occurrences — Editorial

Opening the reading…

Intuitionthe condition applies only to characters that appear

The string is valid when every character that appears contributes the same number of positions. Characters absent from the string do not participate, so their frequency of zero must not be compared with the frequencies of present characters.

Count the occurrences of all 26 lowercase letters. Then scan those counts and use the first positive count as the target frequency. Every later positive count must match it; if none differs, all appearing characters occur equally often.

Approachtwo passes keep counting separate from checking

Create an array of 26 zero counts, because each lowercase letter maps directly to one fixed index and no character needs a dynamically allocated entry.

Scan the string and increment freq[c - 'a'] for each character, because the final decision depends on complete frequencies rather than on adjacent characters.

Set common to zero before scanning the frequency array, because zero means that no appearing character has supplied the comparison target yet.

For each positive frequency, store it in common if common is still zero, because the first appearing character defines the frequency that all other appearing characters must share.

For every later positive frequency, compare it with common and return false immediately when they differ, because one unequal pair is enough to invalidate the whole string.

Return true after the scan finishes, because every non-zero frequency was checked against the same target and no mismatch was found.

Complexitythe alphabet is fixed at 26 lowercase letters

MEASURE	BOUND	WHY
Time	O(n)	The first pass processes each of the n characters once, and the second pass examines exactly 26 counters. Since 26 is a fixed constant, O(n + 26) simplifies to O(n), with no input shape that increases the scan beyond these two passes.
Space	O(1) extra	The frequency array always contains 26 integers, regardless of n. The returned boolean is required output and is excluded from working memory, so the extra space remains O(1) even for the largest allowed string.

Here n is the length of the input string; the alphabet size is fixed at 26.

Annotated solutionC++ · fixed frequency array · two clear passes

CPPCount all letters, then compare every non-zero frequency with the first one.

#include <string>
using namespace std;

class Solution {
public:
    bool areOccurrencesEqual(string s) {
        int freq[26] = {0};

        for (char c : s) {
            freq[c - 'a']++;
        }

        int common = 0;
        for (int i = 0; i < 26; i++) {
            if (freq[i] > 0) {
                if (common == 0) {
                    common = freq[i];
                } else if (freq[i] != common) {
                    return false;
                }
            }
        }

        return true;
    }
};

The important guard is freq[i] > 0. It skips letters that never appear, while common == 0 records that no appearing letter has been seen yet. Because the string is non-empty, at least one counter becomes positive, but the same structure also makes the scan's intent explicit: only present characters define the condition.