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

Examples to Understand Time Complexity

Example 1: Constant Time - O(1)
print("Hello World")
Explanation: The code runs in constant time because it prints "Hello World" only once, no matter the input size.
Time Complexity: O(1)

Example 2: Linear Time - O(n)
n = 8
for i in range(1, n + 1):
    print("Hello World !!!")
Explanation: The code prints "Hello World !!!" n times. As n grows, the runtime grows linearly.
Time Complexity: O(n)

Example 3: Logarithmic Time - O(log n)

n = 8
for i in range(1, n + 1, 2):
    print("Hello World !!!")
Explanation: The loop runs logarithmically because it skips half the steps each time.
Time Complexity: O(log n)

Example 4: Polynomial Time - O(n²)
n = 3
m = 3
arr = [[3, 2, 7], [2, 6, 8], [5, 1, 9]]
sum = 0

for i in range(n):
    for j in range(m):
        sum += arr[i][j]
print(sum)
Explanation: The code uses nested loops to sum all elements in a 2D array.
Time Complexity: O(n * m)

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
       
        num_indices = {}
        for i, num in enumerate(nums):
            if num in num_indices and i - num_indices[num] <= k:
                return True
            num_indices[num] = i

        return False

class Solution:
    def trap(self, height: List[int]) -> int:
        if not height:
            return 0
        left = 0
        right = len(height) - 1
        left_max = right_max = 0
        total = 0
        while left < right:
            if height[left] < height[right]:
                if height[left] >= left_max:
                    left_max = height[left]
                else:
                    total += left_max - height[left]
                left += 1
            else:
                if height[right] >= right_max:
                    right_max = height[right]
                else:
                    total += right_max - height[right]
                right -= 1
        return total

class Solution:
    def nextPermutation(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        r = len(nums)-1
        while r>=1:
            if nums[r] >nums[r-1]:
                if r+1<len(nums) and nums[r+1] >nums[r-1]:
                    k = 2
                    while (r+k<len(nums) and  nums[r+k] >nums[r-1]):
                        k+=1
                    k-=1
                    nums[r+k],nums[r-1]=nums[r-1],nums[r+k]
                else:
                    nums[r],nums[r-1]=nums[r-1],nums[r]
                break
            else:
                r -= 1
        l = len(nums)-1
        while l>r:
            if nums[l] <nums[r]:
                nums[l],nums[r] = nums[r],nums[l]
            l-=1
            r+=1

def threeSum(nums):
    res = []
    nums.sort()
    n = len(nums)
    for i in range(n - 2):
        if i > 0 and nums[i] == nums[i - 1]:
            continue  # Skip duplicate elements for the first element of the triplet
        left, right = i + 1, n - 1
        while left < right:
            current_sum = nums[i] + nums[left] + nums[right]
            if current_sum == 0:
                res.append([nums[i], nums[left], nums[right]])
                # Skip duplicates for the second element
                while left < right and nums[left] == nums[left + 1]:
                    left += 1
                # Skip duplicates for the third element
                while left < right and nums[right] == nums[right - 1]:
                    right -= 1
                left += 1
                right -= 1
            elif current_sum < 0:
                left += 1
            else:
                right -= 1
    return res 

Input: nums = [2, 7, 11, 15], target = 9  
Output: [0, 1]  
Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].  

Input: nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]  
Output: 6  
Explanation: The subarray [4, -1, 2, 1] has the largest sum = 6.  

Input: s = "()[]{}"  
Output: true  

Input: s = "(]"  
Output: false  

import random

class RandomizedSet:
    def __init__(self):
        self.array = []  # For O(1) random access
        self.indices = {}  # Maps elements to their indices

    def insert(self, val: int) -> bool:
        if val in self.indices:
            return False  # Element already exists
        self.indices[val] = len(self.array)
        self.array.append(val)
        return True

    def remove(self, val: int) -> bool:
        if val not in self.indices:
            return False  # Element does not exist
        index = self.indices[val]
        last_element = self.array[-1]
        
        # Swap and remove
        self.array[index] = last_element
        self.indices[last_element] = index
        self.array.pop()
        del self.indices[val]
        return True

    def getRandom(self) -> int:
        return random.choice(self.array)

randomizedSet = RandomizedSet()
print(randomizedSet.insert(1))  # True
print(randomizedSet.remove(2))  # False
print(randomizedSet.insert(2))  # True
print(randomizedSet.getRandom())  # Either 1 or 2
print(randomizedSet.remove(1))  # True
print(randomizedSet.insert(2))  # False
print(randomizedSet.getRandom())  # 2

def findWinners(matches):
    loss_counts = {}
    players = set()

    for winner, loser in matches:
        players.add(winner)
        players.add(loser)
        loss_counts[loser] = loss_counts.get(loser, 0) + 1

    zero_losses = sorted([player for player in players if loss_counts.get(player, 0) == 0])
    one_loss = sorted([player for player in players if loss_counts.get(player, 0) == 1])

    return [zero_losses, one_loss]

matches = [[1, 3], [2, 1], [4, 2], [5, 2]]
result = findWinners(matches)
print(result)  # Output: [[4, 5], [1, 3]]

def restoreString(s, indices):
    result = [''] * len(s)
    for i, idx in enumerate(indices):
        result[idx] = s[i]
    return ''.join(result)

s = "codeleet"
indices = [4, 5, 6, 7, 0, 2, 1, 3]
result = restoreString(s, indices)
print(result)  # Output: "leetcode"