Longest Repeating Character Replacement - Practice Coding Problems

Longest Repeating Character Replacement - Problem

Imagine you have a string of uppercase English letters and a magic wand that can transform any character into any other uppercase letter. You can use this wand at most k times.

Your goal is to create the longest possible substring where all characters are identical. For example, with string "AABABBA" and k = 1, you could change one 'B' to 'A' to get "AAABABA", giving you a substring "AAA" of length 3.

What's the length of the longest substring of identical characters you can achieve?

This is a classic sliding window problem that tests your ability to efficiently track character frequencies while maintaining an optimal window size.

Input & Output

example_1.py — Basic Case

$ Input: s = "ABAB", k = 2

› Output: 4

💡 Note: Replace the two 'A's with 'B's (or vice versa) to get "BBBB" or "AAAA". The entire string becomes the same character with exactly 2 replacements.

example_2.py — Partial Replacement

$ Input: s = "AABABBA", k = 1

› Output: 4

💡 Note: Replace one 'B' with 'A' in the substring "AABA" to get "AAAA" (length 4). This is better than replacing one 'A' with 'B' to get "BBB" (length 3).

example_3.py — No Replacement Needed

$ Input: s = "AAAA", k = 0

› Output: 4

💡 Note: The string already consists of the same character, so no replacements are needed. The entire string length is 4.

Visualization

Tap to expand

Understanding the Visualization

Start Small

Begin with a tiny window at the start of the string

Expand Greedily

Keep growing the window as long as replacements ≤ k

Track the Winner

Always know which character appears most in your window

Shrink When Needed

If window becomes invalid, slide the left side

Remember the Best

Keep track of the largest valid window seen

Key Takeaway

🎯 Key Insight: The sliding window technique transforms an O(n³) brute force solution into an elegant O(n) algorithm by maintaining a dynamic window that expands and contracts based on the validity condition.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with two pointers, each character visited at most twice

✓ Linear Growth

Space Complexity

O(1)

Hash map stores at most 26 uppercase English characters (constant space)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only uppercase English letters
0 ≤ k ≤ s.length

Asked in

f Meta 45 a Amazon 38 ⊞ Microsoft 32 G Google 28

The optimal approach uses the sliding window technique with a hash map to track character frequencies. Key insight: we only need to track the maximum frequency in the current window and slide when window_size - max_freq > k. This achieves O(n) time complexity with O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Map (Optimal)	O(n)	O(1)	Use sliding window technique with character frequency tracking
Brute Force (Check All Substrings)	O(n³)	O(1)	Check every possible substring and count replacements needed

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Initialize left and right pointers at 0, frequency map, and max_freq
Expand window by moving right pointer and updating character frequency
Update max_freq if current character frequency exceeds it
If window_size - max_freq > k, shrink window from left
Update maximum length with current valid window size
Repeat until right pointer reaches end of string

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize window

Start with both pointers at beginning, empty frequency map

Expand window

Move right pointer, add character to frequency map

Check validity

If window_size - max_freq > k, window is invalid

Shrink if needed

Move left pointer to make window valid again

Update result

Track maximum valid window size seen so far

Code -

solution.c — C

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

int characterReplacement(char* s, int k) {
    int left = 0;
    int maxFreq = 0;
    int maxLength = 0;
    int freq[26] = {0};
    int n = strlen(s);
    
    for (int right = 0; right < n; right++) {
        // Expand window - add current character
        int idx = s[right] - 'A';
        freq[idx]++;
        
        // Update max frequency in current window
        if (freq[idx] > maxFreq) {
            maxFreq = freq[idx];
        }
        
        // Check if current window is valid
        int windowSize = right - left + 1;
        if (windowSize - maxFreq > k) {
            int leftIdx = s[left] - 'A';
            freq[leftIdx]--;
            left++;
        }
        
        // Update maximum length
        int currentLength = right - left + 1;
        if (currentLength > maxLength) {
            maxLength = currentLength;
        }
    }
    
    return maxLength;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    char s[1000];
    int k;
    sscanf(line, "%s %d", s, &k);
    
    // Remove quotes from string
    int len = strlen(s);
    if (s[0] == '"') {
        memmove(s, s + 1, len);
        len--;
    }
    if (len > 0 && s[len - 1] == '"') {
        s[len - 1] = '\0';
    }
    
    printf("%d\n", characterReplacement(s, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with two pointers, each character visited at most twice

✓ Linear Growth

Space Complexity

O(1)

Hash map stores at most 26 uppercase English characters (constant space)

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only uppercase English letters
0 ≤ k ≤ s.length

42.3K Views

High Frequency

~18 min Avg. Time

1.8K 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 with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler