Check if All Characters Have Equal Number of Occurrences

Check if All Characters Have Equal Number of Occurrences - Problem

You are given a string s and need to determine if it's a "good" string.

A string is considered good if every character that appears in the string has exactly the same frequency. In other words, all characters must occur the same number of times.

Examples:

"abacbc" is good because 'a', 'b', and 'c' each appear exactly 2 times
"aaabb" is not good because 'a' appears 3 times while 'b' appears 2 times
"aabbcc" is good because all characters appear exactly 2 times

Return true if the string is good, false otherwise.

Input & Output

example_1.py — Python

$ Input: s = "abacbc"

› Output: true

💡 Note: Characters 'a', 'b', and 'c' each appear exactly 2 times, so all have equal frequency.

example_2.py — Python

$ Input: s = "aaabb"

› Output: false

💡 Note: Character 'a' appears 3 times while 'b' appears 2 times. Since frequencies are different, return false.

example_3.py — Python

$ Input: s = "a"

› Output: true

💡 Note: Single character always has equal frequency (trivially true case).

Visualization

Tap to expand

Understanding the Visualization

Count Character Frequencies

Scan the string and build a frequency map: 'a'→2, 'b'→2, 'c'→2

Extract All Frequency Values

Get all frequency counts from the map: [2, 2, 2]

Verify All Equal

Check if all frequencies are the same by comparing with the first frequency

Return Result

Return true if all frequencies are equal, false otherwise

Key Takeaway

🎯 Key Insight: Use a hash table to count frequencies in O(n) time, then verify all frequency values are identical. This is much more efficient than counting each character separately.

Time & Space Complexity

Time Complexity

⏱️

O(n)

First pass through string O(n) + second pass through unique characters O(k) where k ≤ n

✓ Linear Growth

Space Complexity

O(k)

Hash table stores at most k distinct characters where k ≤ n

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only
String is guaranteed to be non-empty

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal solution uses a hash table to count character frequencies in O(n) time. Build a frequency map by iterating through the string once, then verify all frequency values are equal. This approach is efficient with O(n) time complexity and O(k) space complexity where k is the number of unique characters.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Hash Table	O(n)	O(k)	First pass builds frequency map, second pass verifies all frequencies are equal
Brute Force (Nested Character Counting)	O(n²)	O(k)	For each unique character, count its occurrences and compare with others

Two-Pass Hash Table — Algorithm Steps

First pass: iterate through string and build frequency map
After first pass, get the frequency of any character as reference
Second pass: iterate through all frequency values
Compare each frequency with the reference frequency
Return false if any frequency differs, true if all are equal

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass - Build Frequency Map

Scan string 'abacbc' and count: a→2, b→2, c→2

Get Reference Frequency

Take frequency of first character 'a' as reference: 2

Second Pass - Verify All Equal

Check b:2==2✓, c:2==2✓

Result

All frequencies equal reference, return true

Code -

solution.c — C

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

bool areOccurrencesEqual(char* s) {
    int len = strlen(s);
    if (len == 0) return true;
    
    // First pass: build frequency map (assuming ASCII)
    int freqMap[128] = {0};
    for (int i = 0; i < len; i++) {
        freqMap[(int)s[i]]++;
    }
    
    // Find reference frequency (first non-zero frequency)
    int referenceFreq = -1;
    for (int i = 0; i < 128; i++) {
        if (freqMap[i] > 0) {
            referenceFreq = freqMap[i];
            break;
        }
    }
    
    // Second pass: check if all frequencies are equal
    for (int i = 0; i < 128; i++) {
        if (freqMap[i] > 0 && freqMap[i] != referenceFreq) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    // Remove newline and quotes
    s[strcspn(s, "\n")] = 0;
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    printf("%s\n", areOccurrencesEqual(s) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

First pass through string O(n) + second pass through unique characters O(k) where k ≤ n

✓ Linear Growth

Space Complexity

O(k)

Hash table stores at most k distinct characters where k ≤ n

✓ Linear Space

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters only
String is guaranteed to be non-empty

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Hash Table — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler