# Remove the letter to equalize the frequency

## Problem Statement

We are given a 0-indexed string word consisting of lowercase English letters. You need to select one index and remove the letter at that index from the word so that the frequency of every letter present in the word is equal.

Return true if it is possible to remove one letter so that the frequency of all letters in a word is equal, and false otherwise.

Note:

• The frequency of the letter x is the number of times it occurs in the string.
• We must remove exactly one letter and cannot choose to do anything.

### Java Approach 1 Using Brute force

Output:

Code Explanation:

• The equalFrequency Method checks if there exists a letter in the input word that, when removed, results in all remaining letters having equal frequencies. It iterates through each position in the word, simulating the removal of one character at a time. For each simulation, it counts the frequency of each letter and finds the minimum and maximum frequencies.
• If the minimum and maximum frequencies are the same after removal, the Method returns true, indicating that a character can be removed to achieve equal frequencies. If no such character is found for any position, the method returns false. The algorithm utilizes nested loops and conditional checks to analyze the frequency distribution.

Time Complexity:

• The time complexity of the equalFrequency Method is O(N^2), where N is the length of the input word. This is due to the nested loops iterating through each position in the word and, for each position, counting frequencies.

Space Complexity:

• The space complexity is O(1) as the algorithm uses a constant amount of space, independent of the input size. It maintains a fixed-size array to store letter frequencies. Despite the nested loops, the space complexity remains constant, making the algorithm efficient in terms of memory utilization for varying input lengths.

Drawbacks:

• The Above solution uses a brute-force approach by checking every possible scenario where one letter is removed to equalize frequencies. This leads to a time complexity of O(n^2), where n is the length of the input word.
• The algorithm iterates through each character and, for each character, traverses the entire word to simulate its removal. This results in inefficient computation, especially for longer words, as it unnecessarily recalculates frequencies multiple times.

### Java Approach 2 Using Frequency Counting

Output:

Code Explanation:

• The code aims to determine if removing a single character from the input word can make the frequencies of the remaining characters equal. It employs an array to track the frequency of each character. For every character, it simulates removing one occurrence and checks if the remaining frequencies result in a set with only one distinct value (excluding the frequency '0').
• If such a set is found, indicating equal frequencies, the method returns true. This approach optimizes the process by iterating through each character's frequency once.

Time complexity:

• The time complexity of the code is O(n), where n represents the length of input word. This is because the algorithm goes through each character of word at least once, and performs constant-time operations on every one.

Space Complexity:

• The additional space used is constant and independent of the size of input, space complexity is O(1). The algorithm uses a fixed array to count the frequency of characters, and the size (26 elements corresponding with each letter) is always constant.

Drawbacks:

• The Above solution, while efficient in terms of time complexity (O(n)), uses additional space for the frequency array, leading to a space complexity of O(26) or O(1). However, the drawback lies in its inefficiency in handling large input strings.
• The algorithm iterates through each frequency, simulating removal, and then checks if the remaining frequencies are equal. This simulation process, combined with repeated.

### Java Approach 3 Using Hashtable

Output:

Code Explanation:

• The equalFrequency method determines if there is a character in the input word that, when removed, results in all remaining characters having equal frequencies. It uses a HashMap to count the frequency of each character. The Method then iterates through each character's frequency, simulating the removal of one occurrence at a time.
• For each simulation, it creates a set of remaining frequencies and checks if there is only one distinct frequency (excluding '0'). If found, it returns true, indicating that a character can be removed to achieve equal frequencies. If no such character is found for any frequency, the method returns false.

Time Complexity:

• The time complexity of the equalFrequency Method is O(N), where N is the length of the input word. It iterates through each character in the word to count frequencies using a HashMap, making it linear with respect to the input size.

Space Complexity:

• The space complexity is also O(N), as the Method uses a HashMap to store character frequencies. The space required is proportional to the distinct characters in the word. Despite the nested loops, the space complexity remains linear, offering efficient memory utilization for varying input lengths.