Minimum Operations to Make Character Frequencies Equal

Minimum Operations to Make Character Frequencies Equal - Problem

You are given a string s. A string t is called good if all characters of t occur the same number of times.

You can perform the following operations any number of times:

Delete a character from s
Insert a character in s
Change a character in s to its next letter in the alphabet

Note that you cannot change 'z' to 'a' using the third operation.

Return the minimum number of operations required to make s good.

Input & Output

Example 1 — Simple Case

$ Input: s = "abc"

› Output: 0

💡 Note: All characters already appear exactly once, so the string is already good. No operations needed.

Example 2 — Need Balancing

$ Input: s = "aab"

› Output: 1

💡 Note: We have a=2, b=1. To make all frequencies equal to 1, we need 1 operation: change one 'a' to 'c' to get "acb" where a=1, b=1, c=1.

Example 3 — Multiple Operations

$ Input: s = "aaaa"

› Output: 3

💡 Note: We have a=4. To make it good, we can change to get a=1, b=1, c=1, d=1. This requires 3 operations: change 'a'→'b', 'a'→'c', 'a'→'d'.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only lowercase English letters

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 a Amazon 15

The key insight is to enumerate possible target frequencies and use character transformation chains (a→b→c→...) to minimize operations. The optimal approach only tests promising target frequencies based on existing character counts rather than all possibilities. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force Enumeration

⏱️ Time: O(n²) Space: O(1)

For each possible target frequency, calculate the minimum operations needed to make all characters appear exactly that many times. Consider all three operations: delete, insert, and change to next character.

Optimized Frequency Enumeration

⏱️ Time: O(n × 26) Space: O(1)

Count character frequencies, then for each possible target frequency, calculate minimum operations considering that characters can be changed to next letters in the alphabet, creating transformation chains.

Smart Target Selection

⏱️ Time: O(n) Space: O(1)

Instead of testing all possible target frequencies, we identify candidate targets based on existing frequencies and mathematical constraints. We also optimize the operation counting by considering the most efficient transformation paths.

Brute Force Enumeration — Algorithm Steps

Count frequency of each character in the string
For each target frequency from 0 to n, calculate minimum operations
For each character, find cheapest way to reach target frequency
Return minimum across all target frequencies

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how often each character appears

Try All Targets

Test each possible target frequency from 0 to n

Calculate Operations

For each target, sum operations needed for all characters

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

static int freq[256];
static int frequencies[256];
static int sortedFreq[256];

int compare(const void *a, const void *b) {
    return (*(int*)b - *(int*)a); // Descending order
}

int solution(char* s) {
    memset(freq, 0, sizeof(freq));
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        freq[(unsigned char)s[i]]++;
    }
    
    if (len == 0) {
        return 0;
    }
    
    // Collect non-zero frequencies
    int freqCount = 0;
    for (int i = 0; i < 256; i++) {
        if (freq[i] > 0) {
            frequencies[freqCount++] = freq[i];
        }
    }
    
    int minOps = len; // Worst case: delete everything
    
    // Try each possible target frequency
    for (int target = 1; target <= len; target++) {
        // Try different numbers of distinct characters
        for (int numChars = 1; numChars <= 26; numChars++) { // At most 26 letters
            int totalNeeded = numChars * target;
            
            if (totalNeeded <= 0) {
                continue;
            }
                
            // Calculate operations for this configuration
            for (int i = 0; i < freqCount; i++) {
                sortedFreq[i] = frequencies[i];
            }
            qsort(sortedFreq, freqCount, sizeof(int), compare);
            
            int excess = 0;  // Characters that need to be reduced
            int deficit = 0; // Characters that need to be increased
            
            // Calculate excess from existing characters
            int maxLen = freqCount < numChars ? freqCount : numChars;
            for (int i = 0; i < maxLen; i++) {
                int currentFreq = sortedFreq[i];
                if (currentFreq > target) {
                    excess += currentFreq - target;
                } else if (currentFreq < target) {
                    deficit += target - currentFreq;
                }
            }
            
            // Add deficit for completely new characters needed
            if (numChars > freqCount) {
                deficit += (numChars - freqCount) * target;
            }
            
            // Add excess from characters that don't fit in numChars slots
            for (int i = numChars; i < freqCount; i++) {
                excess += sortedFreq[i];
            }
            
            // Operations needed is max of excess and deficit
            // We can change excess chars to fill deficits
            int operations = excess > deficit ? excess : deficit;
            
            if (operations < minOps) {
                minOps = operations;
            }
        }
    }
    
    return minOps;
}

int main() {
    char s[100001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int result = solution(s);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n possible target frequencies, we iterate through up to 26 characters

✓ Linear Growth

Space Complexity

O(1)

Only using a fixed-size frequency array for 26 letters

✓ Linear Space

25.0K Views

Medium Frequency

~35 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Enumeration — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler