Minimum Operations to Make Character Frequencies Equal

Minimum Operations to Make Character Frequencies Equal - Problem

Transform Your String into Perfect Harmony!

You're given a string s and your mission is to make it "good". A string is considered good when all characters appear exactly the same number of times - perfect frequency balance!

You have three powerful operations at your disposal:
• Delete any character from the string
• Insert any character anywhere in the string
• Transform any character to its next letter in the alphabet (but 'z' can't become 'a')

Goal: Find the minimum number of operations needed to achieve this perfect character frequency balance.

Example: "aab" can become good by deleting one 'a' (1 operation) to get "ab" where both characters appear once.

Input & Output

example_1.py — Basic Transformation

$ Input: s = "aab"

› Output: 1

💡 Note: We can delete one 'a' to get "ab" where both characters appear once (frequency = 1). This requires only 1 operation and is optimal.

example_2.py — Mixed Operations

$ Input: s = "abc"

› Output: 0

💡 Note: The string is already good since all characters ('a', 'b', 'c') appear exactly once. No operations needed.

example_3.py — Character Transformation

$ Input: s = "aaa"

› Output: 2

💡 Note: We can transform one 'a' to 'b' (1 op) and another 'a' to 'c' (2 ops) to get "abc" where each appears once. Alternative: delete 2 'a's (2 ops) to get "a". Both give 2 operations.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Character transformations can only go forward in alphabet (a→b→c→...→z)
You cannot transform 'z' to any other character

Visualization

Tap to expand

Delete: Remove instrument performance➕ Insert: Add more performances🔄 Transform: Change instrument type (a→b→c→...)Goal: Minimum total operationsSolution Strategy: Enumerate & OptimizeStep 1: Try Each Possible Target Frequency• Target = 1: All instruments play 1 note each• Target = 2: All instruments play 2 notes each• Target = 3: All instruments play 3 notes each• Calculate operations needed for each target• Return minimum across all targets🎯 Key Insight: Character Transformation ChainsInstruments can transform in sequences: 🎻→🎼→🎵 (violin → score → note)Smart assignment across these chains minimizes total operations!

Understanding the Visualization

Count the Current Performance

Count how many times each instrument currently plays

Choose Target Frequency

Decide how many times each instrument should play in the final performance

Optimize Instrument Chains

Consider transforming instruments in chains (violin→viola→cello) to minimize changes

Calculate Minimum Changes

For each target, find the minimum operations across all possible strategies

Key Takeaway

🎯 Key Insight: By enumerating all possible target frequencies and using character transformation chains optimally, we can find the minimum operations needed to achieve perfect frequency balance. The algorithm considers the cost-benefit of deletions, insertions, and transformations to find the globally optimal solution.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal approach uses enumeration of target frequencies combined with character transformation chains. For each possible target frequency, we calculate the minimum operations needed by considering character transformations (a→b→c→...) and optimally assigning existing characters to minimize total insertions, deletions, and transformations. The key insight is recognizing that characters can form transformation chains, allowing us to redistribute frequencies efficiently across these chains.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized Enumeration with Character Chains	O(n × 26^3)	O(26)	Enumerate target frequencies and use character transformation chains optimally

Optimized Enumeration with Character Chains — Algorithm Steps

Count frequency of each character in the input string
For each possible target frequency from 0 to string length
Create character transformation chains (a→b→c→...→z)
Use dynamic programming to optimally assign characters to chains
Calculate minimum operations needed for current target frequency
Return the minimum across all target frequencies

Visualization

Tap to expand

Step-by-Step Walkthrough

Map Character Chains

Identify transformation chains: a→b→c, d→e→f, etc.

Calculate Chain Costs

For each chain, calculate cost of achieving target frequency

Optimal Assignment

Use DP to assign characters to chains optimally

Sum Minimum Costs

Add up costs for all chains to get total operations

Code -

solution.c — C

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

int minOperations(char* s) {
    int freq[26] = {0};
    int len = strlen(s);
    int uniqueChars = 0;
    
    if (len == 0) return 0;
    
    for (int i = 0; i < len; i++) {
        if (freq[s[i] - 'a'] == 0) uniqueChars++;
        freq[s[i] - 'a']++;
    }
    
    int minOperations = len;
    
    for (int targetFreq = 1; targetFreq <= len; targetFreq++) {
        for (int numDistinct = 1; numDistinct <= 26; numDistinct++) {
            if (targetFreq * numDistinct > len + targetFreq * numDistinct / 2) {
                break;
            }
            
            int operations = 0;
            int charsUsed = 0;
            
            // Use existing characters first
            for (int i = 0; i < 26 && charsUsed < numDistinct; i++) {
                if (freq[i] > 0) {
                    if (freq[i] <= targetFreq) {
                        operations += targetFreq - freq[i];
                    } else {
                        operations += freq[i] - targetFreq;
                    }
                    charsUsed++;
                }
            }
            
            // Delete remaining characters
            for (int i = 0; i < 26; i++) {
                if (freq[i] > 0 && charsUsed > 0) {
                    charsUsed--;
                } else if (freq[i] > 0) {
                    operations += freq[i];
                }
            }
            
            // Add new characters if needed
            int newCharsNeeded = numDistinct - uniqueChars;
            if (newCharsNeeded > 0) {
                operations += newCharsNeeded * targetFreq;
            }
            
            if (operations < minOperations) {
                minOperations = operations;
            }
        }
    }
    
    return minOperations;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newline
    char* start = s;
    if (*start == '"') start++;
    int len = strlen(start);
    if (len > 0 && (start[len-1] == '\n' || start[len-1] == '"')) {
        start[len-1] = '\0';
        len--;
    }
    if (len > 0 && start[len-1] == '"') {
        start[len-1] = '\0';
    }
    
    printf("%d\n", minOperations(start));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × 26^3)

For each target frequency (n possibilities), we solve assignment problem across 26 characters with transformation chains

✓ Linear Growth

Space Complexity

O(26)

Space for frequency counting and DP state for character assignments

✓ Linear Space

52.0K Views

Medium-High Frequency

~35 min Avg. Time

1.5K 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

Optimized Enumeration with Character Chains — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler