# Minimum Deletions to Make Character Frequencies Unique Leetcode Solution June 28, 2022

Competitive programming is essential and today we are going to solve the round bounded in circle leetcode problem. This problem appeared in amazon coding interview.

The question states that:-

A string `s` is called good if there are no two different characters in `s` that have the same frequency.

Given a string `s`, return the minimum number of characters you need to delete to make `s` good.

The frequency of a character in a string is the number of times it appears in the string. For example, in the string `"aab"`, the frequency of `'a'` is `2`, while the frequency of `'b'` is `1`.

Example 1:

```Input: s = "aab"
Output: 0
Explanation: `s` is already good.
```

Example 2:

```Input: s = "aaabbbcc"
Output: 2
Explanation: You can delete two 'b's resulting in the good string "aaabcc".
Another way it to delete one 'b' and one 'c' resulting in the good string "aaabbc".```

Example 3:

```Input: s = "ceabaacb"
Output: 2
Explanation: You can delete both 'c's resulting in the good string "eabaab".
Note that we only care about characters that are still in the string at the end (i.e. frequency of 0 is ignored).
```

Constraints:

• `1 <= s.length <= 105`
• `s` contains only lowercase English letters.

As we can only delete characters, if we have multiple characters having the same frequency, we must decrease all their frequencies of them, except one.

Sort the alphabet characters by their frequencies in reverse order i.e non-increasing order. Iterate on the alphabet characters, and keep decrementing the frequency by 1  of the current character until it reaches a value that has not appeared before and if the value goes in negative then stop when it becomes zero.

Here is my python code:

``````class Solution:
def minDeletions(self, s: str) -> int:
h = {}
for i in s:
if i in h:
h[i]+=1
else:
h[i] = 1

li = []
for i in h.values():
li.append(i)
li.sort(reverse=True)
count = 0
seen = []
i=0
while i<len(li):
if li[i] in seen:
while i<len(li) and li[i] in seen and li[i]>0:
li[i]-=1
count+=1
seen.append(li[i])

else:
seen.append(li[i])
i+=1
return count

``````