let s = "AAABBBBCBB"    // s = "CCIDLRIHDSDSSMES"

let k = 2

​

/*

    `Longest Repeating Character Replacement`

     with the best runtime and memory usage performance.

     Techniques that used are:

     1. two pointer

     2. sliding window

     3. hash maps

     Time Complexity: N i.e. O(N) where N='string length'

     Space Complexity:  

     The English alphabet consists of 26 letters 

     and so in the worst case we could have 26 non-repeating 

     consecutive characters which would cause our hash memory 

     at most to store 26 characters, 

     so space complexity is constant: S(1)

*/

​

const characterReplacement = function(s, k) {

    let [behind, ahead, localMax, globalMax, window_length] = [0, 0, 0, 0, 0]

    let map = {}

​

    while (ahead < s.length) {

        window_length = ahead - behind + 1

        map.hasOwnProperty(s[ahead]) ? map[s[ahead]]++ : map[s[ahead]] = 1

        localMax = Math.max(localMax, map[s[ahead]])

        globalMax = Math.max(globalMax, map[s[ahead]] + k)

​

        console.log(map)

​

        if (localMax + k >= window_length) {

            ahead++

        }  else {

            map[s[behind]]--

            behind++

            ahead++

        }

    }

​

    return Math.min(globalMax, s.length)

}

​

console.log('max:', characterReplacement(s, k))

​

​

// [Log]:

{ A: 1 }

{ A: 2 }

{ A: 3 }

{ A: 3, B: 1 }

{ A: 3, B: 2 }

{ A: 3, B: 3 }

{ A: 2, B: 4 }

{ A: 2, B: 4, C: 1 }

{ A: 1, B: 5, C: 1 }

{ A: 1, B: 6, C: 1 }

​

max: 8

​