Solution: Longest Substring with K Distinct Characters

def longestSubstring(str1, k):
    l = 0
    max_len = 0
    counts = {}

    for r in range(len(str1)):
        # Add in an item to the window, by adding 1 to its count
        counts[str1[r]] += counts.get(str1[r], 0) + 1

        # Now we contract the window if we've seen more than
        # 'k' characters
        while len(counts) > k:
            # Take an item out of the window by subtracting
            # 1 from its ounts
            counts[str1[l]] -= 1

            # If it turns out that we've exhausted this key,
            # delete it from the dict
            if counts[str1[l]] == 0:
                del counts[str1[l]]

            # Then shift our pointer to the right
            l += 1

        max_len = max(max_len, r - l + 1)

     return max_len

class Solution:
  def findLength(self, text, k):
      max_length = float('-inf')
      freq = {}
      j = 0
      
      for i in range(len(text)):
        freq[text[i]] = freq.get(text[i], 0)
        freq[text[i]] += 1 
        if len(freq) <= k:
          max_length = max(max_length, i - j + 1)
        else:
          while len(freq) > k:
            freq[text[j]] -= 1 
            if freq[text[j]] == 0:
              del freq[text[j]]
            j += 1
          
      return max_length 

The current solution uses while(Object.keys()) which increases the time complexity from O(N) to O(N * K) where K is each key in the object that has to be added again into an array for each iteration.

The optimal solution would instead have an int as the counter which gets us back to O(N).

Using set will make code more cleaner

I believe I accounted for the edge cases... As long as you encounter a letter you've seen before, make the window start = window end since you will only be caring about a substring with no duplicates.