test(algorithms, sliding-window): longest repeating char replacement

Author: BrianLusina

algorithms/sliding_window/longest_repeating_char_replacement/__init__.py

@@ -26,7 +26,7 @@ def character_replacement(s: str, k: int) -> int:
 
     At this point, the last valid window has moved one step to the right, but it might still be invalid. As explained
     earlier, we are only interested in larger windows, so we don't need to decrease the window size. We move the window
-    of size i−1 further and further to the right until it becomes valid again.
+    of size l−1 further and further to the right until it becomes valid again.
 
     If we come across a valid window, we try to expand it as much as possible, and the process continues until the right
     pointer reaches the rightmost alphabet of the string. At this point, the size of the window indicates the longest
@@ -40,9 +40,11 @@ def character_replacement(s: str, k: int) -> int:
     are m unique characters, then the memory required is proportional to m. So the space complexity is O(m). Considering
     uppercase English letters only, m=26
 
-    @param s: input string
-    @param k: number of replacements
-    @return: length of the longest substring with repeating characters after at most k replacements
+    Args:
+        s(str): input string
+        k(int): number of replacements
+    Returns:
+        int: length of the longest substring with repeating characters after at most k replacements
     """
     frequency_map = {}
     result = 0

algorithms/sliding_window/longest_repeating_char_replacement/test_longest_repeating_character_replacement.py

@@ -28,6 +28,69 @@ def test_ABCCDC_with_1(self):
         actual = character_replacement(s, k)
         self.assertEqual(expected, actual)
 
+    def test_aaacbbbaabab(self):
+        s = "aaacbbbaabab"
+        k = 2
+        expected = 6
+        actual = character_replacement(s, k)
+        self.assertEqual(expected, actual)
+
+    def test_abbcab(self):
+        s = "abbcab"
+        k = 2
+        expected = 5
+        actual = character_replacement(s, k)
+        self.assertEqual(expected, actual)
+
+    def test_dippitydip(self):
+        s = "dippitydip"
+        k = 4
+        expected = 6
+        actual = character_replacement(s, k)
+        self.assertEqual(expected, actual)
+
+    def test_coollooc(self):
+        s = "coollooc"
+        k = 2
+        expected = 6
+        actual = character_replacement(s, k)
+        self.assertEqual(expected, actual)
+
+    def test_aaaaaaaaaa(self):
+        s = "aaaaaaaaaa"
+        k = 2
+        expected = 10
+        actual = character_replacement(s, k)
+        self.assertEqual(expected, actual)
+
+    def test_lmno(self):
+        s = "lmno"
+        k = 2
+        expected = 3
+        actual = character_replacement(s, k)
+        self.assertEqual(expected, actual)
+
+    def test_xxxxx(self):
+        s = "xxxxx"
+        k = 1
+        expected = 5
+        actual = character_replacement(s, k)
+        self.assertEqual(expected, actual)
+
+    def test_fzffz(self):
+        s = "fzfzfz"
+        k = 6
+        expected = 6
+        actual = character_replacement(s, k)
+        self.assertEqual(expected, actual)
+
+    def test_aabccbb(self):
+        s = "aabccbb"
+        k = 2
+        expected = 5
+        actual = character_replacement(s, k)
+        self.assertEqual(expected, actual)
+
 
 if __name__ == "__main__":
     unittest.main()

algorithms/sliding_window/longest_substring_with_k_repeating_chars/__init__.py

@@ -60,7 +60,7 @@ def longest_substring(s: str, k: int) -> int:
 
     Complexity Analysis
 
-    Time Complexity: O(N^2), where N is the length of string ss. Though the algorithm performs better in most cases,
+    Time Complexity: O(N^2), where N is the length of string s. Though the algorithm performs better in most cases,
     the worst case time complexity is still (N ^ 2).
 
     In cases where we perform split at every index, the maximum depth of recursive call could be O(N). For each
@@ -69,9 +69,11 @@ def longest_substring(s: str, k: int) -> int:
     Space Complexity: O(N) This is the space used to store the recursive call stack. The maximum depth of recursive
     call stack would be O(N).
 
-    @param s: String to evaluate for
-    @param k: length of the longest substring
-    @return: length of longest substring with at most repeating characters of length k
-    @rtype int
+    Args:
+        s: String to evaluate for
+        k: length of the longest substring
+
+    Returns:
+        length of longest substring with at most repeating characters of length k
     """
     return longest_substring_util(s, 0, len(s), k)