int left = 0, right = 0;

while (left < right && right < s.size()) {
    // 增大窗口
    window.add(s[right]);
    right++;
    
    while (window needs shrink) {
        // 缩小窗口
        window.remove(s[left]);
        left++;
    }
}

class Solution(object):
	def lengthOfLongestSubstring(self, s):
		"""
		:type s: str
		:rtype: int
		"""
		max_len = 0
		l = 0
		window = set()
		for r in range(len(s)):
			if s[r] not in window:
				window.add(s[r])
				max_len = max(max_len, r - l + 1)
				continue

			while l < r and s[l] != s[r]:
				window.remove(s[l])
				l += 1
			l += 1

		return max_len

	# solution 1 - sliding window
	# - time: O(s), since one element in s will be push/pop to the window once respectively
	# - space: O(1)
	def minWindow(self, s: str, t: str) -> str:
		tCount = {}
		for char in t:  # time: O(t)
			tCount[char] = tCount.get(char, 0) + 1
		tKeyCount = len(tCount)  # the number of char to be satisfied

		curMinLen = 0
		res = ""

		curWindow = {}  # the window
		curSatisfiedKeyCount = 0
		l = 0
		for r in range(len(s)):  # time: O(s)
			char = s[r]
			curWindow[char] = curWindow.get(char, 0) + 1

			if char in tCount and curWindow[char] == tCount[char]:  # the number of char has satisfied
				curSatisfiedKeyCount += 1

			while curSatisfiedKeyCount == tKeyCount:  # means that t is the substring of the current window
				# update the result
				if curMinLen == 0 or (curMinLen != 0 and (r - l + 1) < curMinLen):  # found an eligible substring
					res = s[l:r + 1]
					curMinLen = r - l + 1

				# shrink the window
				curWindow[s[l]] -= 1
				if s[l] in tCount and curWindow[s[l]] < tCount[s[l]]:
					curSatisfiedKeyCount -= 1
				l += 1

		return res

# solution 1
	def maxProfit(self, prices: List[int]) -> int:
		min_price = prices[0]
		max_profit = 0
		for r in range(1, len(prices)):
			price = prices[r]
			if price < min_price:
				min_price = price

			max_profit = max(max_profit, price - min_price)

		return max_profit
		
# solution 2
	def maxProfit(self, prices: List[int]) -> int:
		max_profit = 0
		l = 0
		r = 1
		while r < len(prices):
			if prices[r] > prices[l]:
				cur_profit = prices[r] - prices[l]
				max_profit = max(max_profit, cur_profit)
			else:
				l = r
			r += 1
			
		return max_profit    

class Solution:  
def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:  
	l = 0  
	window = set()  
	for r in range(len(nums)):  
		if r - l > k:  
			window.remove(nums[l])  
			l += 1  
		if nums[r] in window:  
			return True  
		window.add(nums[r])  
	return False