Update longest repeating character replacement problem

Author: sudheerj

README.md

@@ -82,7 +82,7 @@ List of Programs related to data structures and algorithms
 
    1. Longest substring without repeating characters: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/1.longestSubstringWithoutRepeatingChars/longestSubstringWithoutRepeatingChars.js) [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/1.longestSubstringWithoutRepeatingChars/longestSubstringWithoutRepeatingChars.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/1.longestSubstringWithoutRepeatingChars/longestSubstringWithoutRepeatingChars.md)
 
-   2. Longest repeating character replacement: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/longestRepeatingCharReplacement.js)
+   2. Longest repeating character replacement: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/2.longestRepeatingCharReplacement/longestRepeatingCharReplacement.js) [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/2.longestRepeatingCharReplacement/longestRepeatingCharReplacement.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/2.longestRepeatingCharReplacement/longestRepeatingCharReplacement.md)
 
    3. Minimum window substring: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/minWindowSubstring/minWindowSubstring.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/minWindowSubstring/minWindowSubstring.md)
 

src/java1/algorithms/strings/longestRepeatingCharReplacement.java src/java1/algorithms/strings/longestRepeatingCharReplacement/LongestRepeatingCharReplacement.java

@@ -1,5 +1,5 @@
 //Sliding window: TC:O(n) SC: O(1)
-package java1.algorithms.strings;
+package java1.algorithms.strings.longestRepeatingCharReplacement;
 
 public class LongestRepeatingCharReplacement {
     private static int longestCharReplacement(String str, int target) {
@@ -20,7 +20,9 @@ private static int longestCharReplacement(String str, int target) {
     }
 
     public static void main(String[] args) {
-        String str = "AAABABBAA";
-        System.out.println(longestCharReplacement(str, 2));
+        String str1 = "AAABABBAA";
+        System.out.println(longestCharReplacement(str1, 2));
+        String str2 = "BBBB";
+        System.out.println(longestCharReplacement(str2, 2));
     }
 }

src/java1/algorithms/strings/longestRepeatingCharReplacement/LongestRepeatingCharReplacement.md

@@ -0,0 +1,39 @@
+**Description:**
+Given a string `str` and an integer `n`. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most `n` times.
+
+Return the length of the longest substring containing the same letter you can get after performing the above operations.
+
+### Examples
+
+Example 1:
+Input: str = "AAABABBAA", n = 2
+Output: 6
+
+Example 2:
+Input: str = "BBBB", n = 2
+Output: 4
+
+**Algorithmic Steps**
+This problem is solved with the help of **sliding window** approach using two pointer variables. The algorithmic approach can be summarized as follows:
+
+1. Initialize character count varaible(i.e, `charCount`) to store the number of times a capital letter appears.
+
+2. Initialize maximum length of the substring(`maxLength`), maximum chracter frequency(`maxCharFrequency`), left and right pointers(`left` & `right`) to 0.
+
+3. Iterate over the input string using right pointer.
+
+4. Calculate the maximum character freuency by taking the maximum between itself and character count of current character.
+
+5. Create a nested loop to shrink(i.e, increasing left pointer) the substring's left boundary incase of repeatitive character found. This loop is executed until the difference between substring length and maximum character frequency is greater than given target.
+
+6. For each nested iteration, the character count is decreased and left pointer incremented.
+
+7. Calculate the maximum substring length by taking maximum between maximum itself and substring length.
+
+8. Return `maxLength` to indicate the longest repeating chracter replacement substring.
+
+
+**Time and Space complexity:**
+
+This algorithm takes a time complexity of `O(n)`(`O(26 * n)`) because we are traversing the string only once. 
+Also, the character count requires 26 letters to provide character frequency. i.e, It requires space complexity of `O(1)`(~`O(26)`).

src/javascript/algorithms/strings/longestRepeatingCharReplacement.js src/javascript/algorithms/strings/2.longestRepeatingCharReplacement/longestRepeatingCharReplacement.js

@@ -1,13 +1,13 @@
 //Sliding window: TC:O(n) SC: O(1)
 function longestCharReplacement(str, target) {
-    let charFrequency = new Array(26).fill(0);;
-    let maxLength = 0, maxFrequency = 0;
+    let charCount = new Array(26).fill(0);;
+    let maxLength = 0, maxCharFrequency = 0;
     let left = 0;
 
     for(let right = 0; right < str.length; right++) {
-        maxFrequency = Math.max(maxFrequency, ++charFrequency[str.charCodeAt(right) - "A".charCodeAt(0)]);
-        while((right-left+1-maxFrequency) > target) {
-            charFrequency[str.charCodeAt(left) - "A".charCodeAt(0)]--;
+        maxCharFrequency = Math.max(maxCharFrequency, ++charCount[str.charCodeAt(right) - "A".charCodeAt(0)]);
+        while((right-left+1-maxCharFrequency) > target) {
+            charCount[str.charCodeAt(left) - "A".charCodeAt(0)]--;
             left++;
         }
         maxLength = Math.max(maxLength, right-left+1);

src/javascript/algorithms/strings/2.longestRepeatingCharReplacement/longestRepeatingCharReplacement.md

@@ -0,0 +1,39 @@
+**Description:**
+Given a string `str` and an integer `n`. You can choose any character of the string and change it to any other uppercase English character. You can perform this operation at most `n` times.
+
+Return the length of the longest substring containing the same letter you can get after performing the above operations.
+
+### Examples
+
+Example 1:
+Input: str = "AAABABBAA", n = 2
+Output: 6
+
+Example 2:
+Input: str = "BBBB", n = 2
+Output: 4
+
+**Algorithmic Steps**
+This problem is solved with the help of **sliding window** approach using two pointer variables. The algorithmic approach can be summarized as follows:
+
+1. Initialize character count varaible(i.e, `charCount`) to store the number of times a capital letter appears.
+
+2. Initialize maximum length of the substring(`maxLength`), maximum chracter frequency(`maxCharFrequency`), left and right pointers(`left` & `right`) to 0.
+
+3. Iterate over the input string using right pointer.
+
+4. Calculate the maximum character freuency by taking the maximum between itself and character count of current character.
+
+5. Create a nested loop to shrink(i.e, increasing left pointer) the substring's left boundary incase of repeatitive character found. This loop is executed until the difference between substring length and maximum character frequency is greater than given target.
+
+6. For each nested iteration, the character count is decreased and left pointer incremented.
+
+7. Calculate the maximum substring length by taking maximum between maximum itself and substring length.
+
+8. Return `maxLength` to indicate the longest repeating chracter replacement substring.
+
+
+**Time and Space complexity:**
+
+This algorithm takes a time complexity of `O(n)`(`O(26 * n)`) because we are traversing the string only once. 
+Also, the character count requires 26 letters to provide character frequency. i.e, It requires space complexity of `O(1)`(~`O(26)`).