Remove Letter To Equalize Frequency - Practice Coding Problems

Remove Letter To Equalize Frequency - Problem

You're given a string of lowercase English letters and need to determine if you can make all remaining characters appear with equal frequency by removing exactly one character.

Think of it like balancing a scale: after removing one letter, every unique character that remains must appear the same number of times. For example, if you have the string "aabbcc", all letters appear twice, so removing any one letter would break this balance. But if you had "aaabbc", removing one 'a' would leave you with "aabbc" where 'a' appears 2 times, 'b' appears 2 times, and 'c' appears 1 time - not balanced.

Key Rules:

You must remove exactly one character (no more, no less)
After removal, all remaining unique characters must have identical frequencies
Return true if this is possible, false otherwise

Input & Output

example_1.py — Basic Case

$ Input: word = "abcc"

› Output: true

💡 Note: We can remove one 'c' to get "abc" where each character appears exactly once (frequency = 1)

example_2.py — Equal Frequencies

$ Input: word = "aabbcc"

› Output: false

💡 Note: All characters already have equal frequency (2). Removing any one character breaks this balance and makes frequencies unequal

example_3.py — Single Character

$ Input: word = "a"

› Output: true

💡 Note: After removing the only character 'a', we have an empty string which vacuously satisfies the equal frequency condition

Constraints

1 ≤ word.length ≤ 10⁵
word consists of lowercase English letters only
You must remove exactly one character

Visualization

Tap to expand

Understanding the Visualization

Count Books

Count how many books are on each shelf (character frequencies)

Analyze Pattern

Look for patterns where removing one book creates balance

Valid Patterns

Check specific cases: all shelves have 1 book, or one shelf has 1 extra book, etc.

Key Takeaway

🎯 Key Insight: Only specific frequency distributions allow equal frequencies after one removal - analyze the pattern instead of trying every possibility!

Asked in

f Meta 15 G Google 12 a Amazon 8 ⊞ Microsoft 6

The optimal approach uses frequency analysis to identify specific patterns where removing one character creates equal frequencies. Instead of trying every removal, we count character frequencies and check if the distribution matches valid patterns: all frequencies equal to 1, one character with frequency+1, or one character appearing once with others equal.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try Every Removal)	O(n²)	O(n)	Try removing each character one by one and check if remaining frequencies are equal
Two-Pass Hash Table	O(n)	O(1)	First count all frequencies, then analyze patterns to determine if removal can work

Brute Force (Try Every Removal) — Algorithm Steps

Iterate through each position in the string
For each position, create a new string without that character
Count the frequency of each character in the modified string
Check if all frequencies are equal
If yes, return true; if no valid removal found, return false

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Position 0

Remove first character and count remaining frequencies

Try Position 1

Remove second character and count remaining frequencies

Continue

Keep trying each position until equal frequencies found or all positions exhausted

Code -

solution.c — C

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

bool equalFrequency(char* word) {
    int n = strlen(word);
    
    for (int i = 0; i < n; i++) {
        // Count frequencies without character at position i
        int freq[26] = {0};
        
        for (int j = 0; j < n; j++) {
            if (j != i) {
                freq[word[j] - 'a']++;
            }
        }
        
        // Find target frequency (first non-zero)
        int targetFreq = -1;
        for (int k = 0; k < 26; k++) {
            if (freq[k] > 0) {
                targetFreq = freq[k];
                break;
            }
        }
        
        // Check if all non-zero frequencies are equal
        bool allEqual = true;
        for (int k = 0; k < 26; k++) {
            if (freq[k] > 0 && freq[k] != targetFreq) {
                allEqual = false;
                break;
            }
        }
        
        if (allEqual) return true;
    }
    
    return false;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n positions, we count frequencies of n-1 characters

⚠ Quadratic Growth

Space Complexity

O(n)

HashMap to store character frequencies for each attempt

⚡ Linearithmic Space

26.8K Views

Medium Frequency

~25 min Avg. Time

890 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

Brute Force (Try Every Removal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler