#2423

Easy

LeetCode Problem Workspace

Remove Letter To Equalize Frequency

Determine if removing a single letter from a string can make all remaining letters have identical frequency efficiently.

hash table string counting

Problem Statement

Given a string word consisting of lowercase English letters, determine if you can remove exactly one letter to make all remaining letters have the same frequency. You may remove any single letter at any index.

Return true if there exists such a removal that results in equal frequency for all letters, and false otherwise. The string length is at least 2 and at most 100.

Examples

Example 1

Input: word = "abcc"

Output: true

Select index 3 and delete it: word becomes "abc" and each character has a frequency of 1.

Example 2

Input: word = "aazz"

Output: false

We must delete a character, so either the frequency of "a" is 1 and the frequency of "z" is 2, or vice versa. It is impossible to make all present letters have equal frequency.

Constraints

2 <= word.length <= 100
word consists of lowercase English letters only.

Solution Approach

Count Letter Frequencies

Use a hash table to count occurrences of each character in the string. This forms the basis to analyze which removal could equalize frequencies.

Test Removals Efficiently

Iterate over unique letters and simulate removing one occurrence of each. After each simulated removal, check if all remaining frequencies match. Stop early once a valid configuration is found.

Handle Edge Cases and Single Letters

Consider cases where one letter occurs only once or all letters already have the same frequency. Ensure your hash table handles these without extra computation or off-by-one errors.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

Time complexity is O(N) to count letters and O(U) to check possible removals, where N is string length and U is number of unique letters (max 26). Space complexity is O(U) for the hash table storing frequencies.

What Interviewers Usually Probe

Check if the candidate correctly uses a hash table for frequency counting.
Look for handling of single-character edge cases and uniform strings.
Expect the candidate to simulate removal efficiently rather than reconstructing the string each time.

Common Pitfalls or Variants

Common pitfalls

Failing to consider letters that appear only once can lead to incorrect results.
Not updating frequency counts correctly during simulated removal can cause logic errors.
Overcomplicating the solution instead of leveraging hash table counting pattern.

Follow-up variants

Instead of removing one letter, allow removing up to K letters to equalize frequency.
Check if adding a single letter can make all frequencies equal.
Determine the minimum number of removals to achieve equal frequency.

FAQ

What is the best approach to Remove Letter To Equalize Frequency?

Use a hash table to count frequencies and test removing each unique letter to see if remaining frequencies are equal.

Can this be solved without a hash table?

Brute force without a hash table is possible but less efficient; hash tables streamline counting and comparison.

What if all letters already have the same frequency?

Removing any single letter still works if it leaves the rest with equal frequencies, otherwise check carefully.

Does removing a letter from the start or end matter?

Position does not matter; only the letter counts affect frequency equality.

How does the Hash Table plus String pattern apply here?

The pattern is used to map each letter to its frequency, allowing quick checks of equalization after simulated removals.

terminal

Solution

Solution 1: Counting + Enumeration

First, we use a hash table or an array of length $26$ named $cnt$ to count the number of occurrences of each letter in the string.

1

2

3

4

5

6

7

8

9

class Solution:
    def equalFrequency(self, word: str) -> bool:
        cnt = Counter(word)
        for c in cnt.keys():
            cnt[c] -= 1
            if len(set(v for v in cnt.values() if v)) == 1:
                return True
            cnt[c] += 1
        return False

Continue Practicing

#2384 largest palindromic number #2351 first letter to appear twice #2506 count pairs of similar strings