Longest Repeating Character Replacement

Longest Repeating Character Replacement - Problem

You are given a string s and an integer k. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most k times.

Return the length of the longest substring containing the same letter you can get after performing the above operations.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: Replace the 2 'B's with 'A's (or 2 'A's with 'B's) to get "AAAA" or "BBBB". Maximum length is 4.

Example 2 — Limited Replacements

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

› Output: 4

💡 Note: Replace one 'B' to get "AABAAAA" or similar. The longest substring of same characters is 4.

Example 3 — All Same Characters

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

› Output: 4

💡 Note: All characters are already the same, so no replacements needed. Length is 4.

Constraints

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

Visualization

Tap to expand

Asked in

M Microsoft 45 a Amazon 38 G Google 32 f Facebook 28

The key insight is using a sliding window with character frequency tracking. A window is valid if window_length - max_frequency ≤ k. Best approach is sliding window with Time: O(n), Space: O(1).

Common Approaches

✓ Prefix Sum

⏱️ Time: N/A Space: N/A

Brute Force - Check All Substrings

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

For each starting position, extend the substring and count how many characters need to be replaced to make all characters the same. Keep track of the maximum length found.

Sliding Window - Optimal Solution

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

Maintain a sliding window with character frequencies. Expand the window while tracking the most frequent character. When replacements needed exceed k, shrink the window from left.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int remainder;
    int index;
} MapEntry;

int solution(int* nums, int numsSize, int p) {
    long long total = 0;
    for (int i = 0; i < numsSize; i++) {
        total += nums[i];
    }
    total %= p;
    
    if (total == 0) {
        return 0;
    }
    
    MapEntry remainderMap[1001];
    int mapSize = 0;
    remainderMap[mapSize++] = (MapEntry){0, -1};
    
    long long prefixSum = 0;
    int minLen = numsSize;
    
    for (int i = 0; i < numsSize; i++) {
        prefixSum = (prefixSum + nums[i]) % p;
        int target = (int)((prefixSum - total + p) % p);
        
        for (int j = 0; j < mapSize; j++) {
            if (remainderMap[j].remainder == target) {
                int len = i - remainderMap[j].index;
                if (len < minLen && len < numsSize) {
                    minLen = len;
                }
                break;
            }
        }
        
        int found = 0;
        for (int j = 0; j < mapSize; j++) {
            if (remainderMap[j].remainder == prefixSum) {
                remainderMap[j].index = i;
                found = 1;
                break;
            }
        }
        if (!found) {
            remainderMap[mapSize++] = (MapEntry){(int)prefixSum, i};
        }
    }
    
    return minLen < numsSize ? minLen : -1;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    int p;
    scanf("%d", &p);
    
    int result = solution(nums, numsSize, p);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

125.0K Views

High Frequency

~25 min Avg. Time

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

Algorithm Steps — Algorithm Steps

Code -

Time & Space Complexity

Select Compiler