Replace the Substring for Balanced String

Replace the Substring for Balanced String - Problem

You are given a string s containing only four specific characters: 'Q', 'W', 'E', and 'R'. Think of this as a special encoding where each character must appear in perfect balance.

A string is considered balanced if each of the four characters appears exactly n/4 times, where n is the total length of the string. Your goal is to find the minimum length substring that you can replace with any other string of the same length to make the entire string balanced.

Example: If s = "QWER", it's already balanced (each character appears once). If s = "QQWE", you need to replace at least one character to balance it.

Return 0 if the string is already balanced, otherwise return the minimum replacement length needed.

Input & Output

example_1.py — Basic Case

$ Input: s = "QWER"

› Output: 0

💡 Note: The string is already balanced. Each character appears exactly once (n/4 = 4/4 = 1), so no replacement is needed.

example_2.py — Need Replacement

$ Input: s = "QQWE"

› Output: 1

💡 Note: We have 2 Q's, 1 W, 1 E, and 0 R's. We need exactly 1 of each. We can replace any single Q with R to get "QRWE" which is balanced.

example_3.py — Multiple Excess

$ Input: s = "QQQQQWWWWWEEEERRRR"

› Output: 4

💡 Note: String length is 16, so we need 4 of each character. We have 5 Q's, 5 W's, 4 E's, 4 R's. We need to replace a substring containing the excess Q and W, minimum length is 4.

Visualization

Tap to expand

Understanding the Visualization

Measure Current Ingredients

Count how much of each ingredient (Q, W, E, R) you currently have

Identify Excess

Determine which ingredients exceed the target amount (n/4 of each)

Find Optimal Scoop

Use sliding window to find the smallest portion that contains enough excess ingredients

Replace for Balance

Replace that portion with the right mix to achieve perfect balance

Key Takeaway

🎯 Key Insight: We only need to find and replace the minimum substring containing all excess characters. The sliding window technique efficiently finds this optimal substring in linear time.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string with each character visited at most twice (once by right pointer, once by left pointer)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for character counters and pointers

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
n is divisible by 4
s consists only of 'Q', 'W', 'E', and 'R'
Note: Since n must be divisible by 4, n/4 is always an integer

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses a sliding window approach in O(n) time. First identify which characters appear more than n/4 times (excess characters). Then use two pointers to find the minimum substring containing enough excess characters that can be replaced to achieve perfect balance. The key insight is that we only need to replace the excess portions, not reorganize the entire string.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window (Optimal)	O(n)	O(1)	Use sliding window to find the minimum substring containing all excess characters
Brute Force (Try All Substrings)	O(n³)	O(1)	Check every possible substring to see if replacing it would balance the string

Sliding Window (Optimal) — Algorithm Steps

Count frequency of each character and identify excess characters
If no excess characters, string is already balanced, return 0
Use sliding window to find minimum substring containing all excess characters
Expand right pointer until window contains enough excess characters
Shrink left pointer while maintaining validity
Track minimum valid window size

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify Excess

Find which characters appear more than n/4 times

Expand Window

Move right pointer until window contains enough excess characters

Shrink Window

Move left pointer while maintaining validity

Track Minimum

Keep track of the minimum valid window size

Code -

solution.c — C

#include <stdio.h>
#include <string.h>
#include <stdbool.h>

int balancedString(char* s) {
    int n = strlen(s);
    int target = n / 4;
    
    // Count frequencies
    int count[256] = {0};
    for (int i = 0; i < n; i++) {
        count[s[i]]++;
    }
    
    // Find excess characters
    int excess[256] = {0};
    bool hasExcess = false;
    char chars[] = "QWER";
    for (int i = 0; i < 4; i++) {
        if (count[chars[i]] > target) {
            excess[chars[i]] = count[chars[i]] - target;
            hasExcess = true;
        }
    }
    
    // If no excess, already balanced
    if (!hasExcess) {
        return 0;
    }
    
    // Sliding window
    int left = 0;
    int minLen = n;
    int windowCount[256] = {0};
    
    for (int right = 0; right < n; right++) {
        char c = s[right];
        if (excess[c] > 0) {
            windowCount[c]++;
        }
        
        // Try to shrink window
        while (left <= right) {
            bool valid = true;
            for (int i = 0; i < 4; i++) {
                if (windowCount[chars[i]] < excess[chars[i]]) {
                    valid = false;
                    break;
                }
            }
            
            if (!valid) break;
            
            int currentLen = right - left + 1;
            if (currentLen < minLen) {
                minLen = currentLen;
            }
            
            char leftChar = s[left];
            if (excess[leftChar] > 0) {
                windowCount[leftChar]--;
            }
            left++;
        }
    }
    
    return minLen;
}

int main() {
    char s[100001];
    scanf("%s", s);
    // Remove quotes if present
    int len = strlen(s);
    if (s[0] == '"' && s[len-1] == '"') {
        memmove(s, s+1, len-2);
        s[len-2] = '\0';
    }
    printf("%d\n", balancedString(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string with each character visited at most twice (once by right pointer, once by left pointer)

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for character counters and pointers

✓ Linear Space

Constraints

1 ≤ n ≤ 10⁵
n is divisible by 4
s consists only of 'Q', 'W', 'E', and 'R'
Note: Since n must be divisible by 4, n/4 is always an integer

28.4K Views

Medium Frequency

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sliding Window (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler