Merge pull request ByteByteGoHq#15 from marttp/kotlin-sliding-windows

Kotlin Chapter 5: Sliding Windows

Author: Destiny-02

kotlin/Sliding Windows/LongestSubstringWithUniqueChars.kt

@@ -0,0 +1,21 @@
+fun longestSubstringWithUniqueChars(s: String): Int {
+    var maxLen = 0
+    val hashSet = mutableSetOf<Char>()
+    var left = 0
+    var right = 0
+    while (right < s.length) {
+        // If we encounter a duplicate character in the window, shrink
+        // the window until it's no longer a duplicate.
+        while (s[right] in hashSet) {
+            hashSet.remove(s[left])
+            left++
+        }
+        // Once there are no more duplicates in the window, update
+        // 'maxLen' if the current window is larger.
+        maxLen = maxOf(maxLen, right - left + 1)
+        hashSet.add(s[right])
+        // Expand the window.
+        right++
+    }
+    return maxLen
+}

kotlin/Sliding Windows/LongestSubstringWithUniqueCharsOptimized.kt

@@ -0,0 +1,22 @@
+fun longestSubstringWithUniqueCharsOptimized(s: String): Int {
+    var maxLen = 0
+    val prevIndexes = mutableMapOf<Char, Int>()
+    var left = 0
+    var right = 0
+    while (right < s.length) {
+        // If a previous index of the current character is present
+        // in the current window, it's a duplicate character in the
+        // window.
+        if (s[right] in prevIndexes && prevIndexes[s[right]]!! >= left) {
+            // Shrink the window to exclude the previous occurrence
+            // of this character.
+            left = prevIndexes[s[right]]!! + 1
+        }
+        // Update 'maxLen' if the current window is larger.
+        maxLen = maxOf(maxLen, right - left + 1)
+        prevIndexes[s[right]] = right
+        // Expand the window.
+        right++
+    }
+    return maxLen
+}

kotlin/Sliding Windows/LongestUniformSubstringAfterReplacements.kt

@@ -0,0 +1,30 @@
+fun longestUniformSubstringAfterReplacements(s: String, k: Int): Int {
+    val freqs = mutableMapOf<Char, Int>()
+    var highestFreq = 0
+    var maxLen = 0
+    var left = 0
+    var right = 0
+    while (right < s.length) {
+        // Update the frequency of the character at the right pointer
+        // and the highest frequency for the current window.
+        freqs[s[right]] = freqs.getOrDefault(s[right], 0) + 1
+        highestFreq = maxOf(highestFreq, freqs[s[right]]!!)
+        // Calculate replacements needed for the current window.
+        val numCharsToReplace = (right - left + 1) - highestFreq
+        // Slide the window if the number of replacements needed exceeds
+        // 'k'. The right pointer always gets advanced, so we just need
+        // to advance 'left'.
+        if (numCharsToReplace > k) {
+            // Remove the character at the left pointer from the hash map
+            // before advancing the left pointer.
+            freqs[s[left]] = freqs[s[left]]!! - 1
+            left++
+        }
+        // Since the length of the current window increases or stays the
+        // same, assign  the length of the current window to 'maxLen'.
+        maxLen = right - left + 1
+        // Expand the window.
+        right++
+    }
+    return maxLen
+}

kotlin/Sliding Windows/SubstringAnagrams.kt

@@ -0,0 +1,35 @@
+fun substringAnagrams(s: String, t: String): Int {
+    val lenS = s.length
+    val lenT = t.length
+    if (lenT > lenS) {
+        return 0
+    }
+    var count = 0
+    val expectedFreqs = IntArray(26)
+    val windowFreqs = IntArray(26)
+    // Populate 'expected_freqs' with the characters in string 't'.
+    for (c in t) {
+        expectedFreqs[c - 'a']++
+    }
+    var left = 0
+    var right = 0
+    while (right < lenS) {
+        // Add the character at the right pointer to 'window_freqs'
+        // before sliding the window.
+        windowFreqs[s[right] - 'a']++
+        // If the window has reached the expected fixed length, we
+        // advance the left pointer as well as the right pointer to
+        // slide the window.
+        if (right - left + 1 == lenT) {
+            if (windowFreqs.contentEquals(expectedFreqs)) {
+                count++
+            }
+            // Remove the character at the left pointer from
+            // 'window_freqs' before advancing the left pointer.
+            windowFreqs[s[left] - 'a']--
+            left++
+        }
+        right++
+    }
+    return count
+}