# Leetcode Longest Repeating Character Replacement problem solution

In this Leetcode Longest Repeating Character Replacement problem solution, 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.

## Problem solution in Python.

```class Solution(object):
def characterReplacement(self, s, k):
"""
:type s: str
:type k: int
:rtype: int
using the sliding window technique
"""
window_start = 0
longest_substring, most_repeated = 0 , 0
freq_map = {}

for window_end in range(len(s)):
curr_char = s[window_end]
if curr_char not in freq_map:
freq_map[curr_char] = 0
freq_map[curr_char] += 1

most_repeated = max(most_repeated, freq_map[curr_char])

if window_end - window_start + 1 - most_repeated > k:
left_char = s[window_start]
freq_map[left_char] -= 1
window_start += 1
longest_substring = max(longest_substring, window_end - window_start + 1)

return longest_substring
```

## Problem solution in Java.

```public int characterReplacement(String s, int k) {
int start=0;
int longCharCount=0;
Map<Character, Integer> map = new HashMap<>();
int maxLength=0;

for(int end=0;end<s.length();end++){
char endchar = s.charAt(end);
map.put(endchar, map.getOrDefault(endchar,0)+1);
longCharCount = Math.max(longCharCount, map.get(endchar));

if(end-start+1-longCharCount >k){
char startChar=s.charAt(start);
map.put(startChar, map.getOrDefault(startChar,0)-1);
start++;
}

maxLength = Math.max(maxLength, end-start+1);
}

return maxLength;

}
```

## Problem solution in C++.

```class Solution {
public:
int characterReplacement(string s, int k) {
int size = s.size(); int ret = 0;
vector<int> count(26, 0);
int start = 0; int end = 0; int Freq = 0;
for(; end<size; end++){
count[s[end]-'A'] += 1;
Freq = max(Freq, count[s[end]-'A']);
while((end-start+1)-Freq > k) {

count[s[start]-'A'] -= 1;
start += 1;

}
ret=max(ret,end-start+1);
}
return ret;
}
};
```

## Problem solution in C.

```int characterReplacement(char * s, int k){
if(s[0]==0)return 0;
int n=strlen(s);
int max=0;
int i;
int diff=0;
int *record=calloc(26,4);
int l;

for(i=0,l=0;i<n;i++){
if(++record[s[i]-'A']<=max){
if(diff==k){
record[s[l++]-'A']--;
}
else{
diff++;
}
}
else {
max++;
}
}
return max+diff;
}
```