### -> -> -> USER: P0

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] > n:
            dq.pop(0)
            
        while # TODO: fill this part
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[i], i))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P1

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result
0
assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P2

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and 0 <= i <= k:
            dq.pop(0)
            
        while len(dq) != 0:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((n, i))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P3

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and # TODO: fill this part
            dq.pop(0)
            
        while dp is not None:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            # TODO: fill this part
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P4

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] <= i - k + 1:
            dq.pop(0)
            
        while nums[dq[-1]] > n and dq != []:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[0], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P5

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P6

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append()
            
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P7

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and n-k+1>0:
            dq.pop(0)
            
        while dq:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            # TODO: fill this part
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P8

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < (i - k + 1):
            dq.pop(0)
            
        while dq != [] and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i > k - 1:
            result.append(nums[dq[0]])
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P9

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P10

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i -k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], nums.index(nums[dq[0]])))
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P11

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            # TODO: fill this part
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P12

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and len(dq) > k:
            dq.pop(0)
            
        while # TODO: fill this part
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            min_n = min(nums[dq[0]:dq[-1]])
            curr_index = 0
            for j in dq:
                if nums[j] == min_n:
                    curr_index = j
            
            result.append((min_n, curr_index))
            
    return result

print(sliding_window_minimum([4, 2, 12, 3, 8], 3))
assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P13

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1: # TODO: fill this part
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n: # TODO: fill this part
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], i))# TODO: fill this part
            
    return result

print(sliding_window_minimum([4, 2, 12, 3, 8], 3))
print(sliding_window_minimum([1, 3, -1, -3, 5], 2))
print(sliding_window_minimum([10, 5, 2, 7, 8, 7], 3))


assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P14

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] == i - k:
            dq.pop(0)
            
        while dq and nums[dq[-1]] >= n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P15

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and len(dq) > 0:
            dq.pop(0)
            
        while dq:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append(nums[i])
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P16

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[i] :# TODO: fill this part
            dq.pop(0)
            
        while dq and nums[dq[i]] > n# TODO: fill this part
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((n, i))
            # TODO: fill this part
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P17

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] > i:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

# assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
# assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
# assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

print(sliding_window_minimum([4, 2, 12, 3, 8], 3))

##############

### -> -> -> USER: P18

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and len(lst) - k != 0:
            dq.pop(0)
            
        while not len(lst) == 0:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            # TODO: fill this part
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P19

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and nums[dq[-1]] < nums:
            dq.pop(0)
            
        while 
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq.pop(0)dq.pop(0))
            dq = 
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P20

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and nums[dq[0]] > nums[i]:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > nums[i]:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[i], i))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P21

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    if k > len(nums):
        return [(min(nums), nums.index(min(nums)))]
    
    for i, n in enumerate(nums):
        if dq and # TODO: fill this part:
            dq.pop(0)
            
        while # TODO: fill this part:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            # TODO: fill this part:
            
    return result

assert sliding_window_minimum([1], 2) == [(1, 0)]
assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P22

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            # TODO: fill this part
            min_i = dq[0]
            result.append((nums[min_i], min_i))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P23

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] > i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[0]] < n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append(nums[dq[0]])
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P24

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P25

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P26

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] > i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append(nums[dq[0]])
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P27

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P28

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P29

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[-1][-1] < i - k - 2:
            dq.pop(0)
            
        while dq:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            dq.append((i, n))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P30

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:# TODO: fill this part
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:# TODO: fill this part
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[-1]], (dq[-1]) - (i - k + 1)))
            
    return result

print(sliding_window_minimum([4, 2, 12, 3, 8], 3))
assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P31

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i-k+1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P32

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] < nums[i]:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append(nums[dq[0]])
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P33

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):

        if dq and dq[0] < 1 + i - k:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P34

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] < n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append(nums[dq[0]])
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P35

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k:
            dq.pop(0)
            
        while dq and nums[dq[0]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P36

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P37

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    # I DID NOT UNDERSTAND THIS ONE AT ALL
    for i, n in enumerate(nums):
        if dq and # TODO: fill this part
            dq.pop(0)
            
        while # TODO: fill this part
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            # TODO: fill this part
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P38

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and i < k - 1:# TODO: fill this part
            dq.pop(0)
            
        while dq:# TODO: fill this part
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            # TODO: fill this part
            result.append((min(dq), k - 1))
            
    return result

print(sliding_window_minimum([4, 2, 12, 3, 8], 3))
print(sliding_window_minimum([1, 3, -1, -3, 5], 2))
print(sliding_window_minimum([10, 5, 2, 7, 8, 7], 3))

# assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
# assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
# assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P39

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append(nums[dq[0]])
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P40

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] < i - k + 1:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]], dq[0]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############

### -> -> -> USER: P41

def sliding_window_minimum(nums: list[int], k: int) -> list[tuple[int, int]]:
    
    dq = []
    result = []
    
    for i, n in enumerate(nums):
        if dq and dq[0] <= i - k:
            dq.pop(0)
            
        while dq and nums[dq[-1]] > n:
            dq.pop()
            
        dq.append(i)
        
        if i >= k - 1:
            result.append((nums[dq[0]]))
            
    return result

assert sliding_window_minimum([4, 2, 12, 3, 8], 3) == [(2, 1), (2, 1), (3, 3)]
assert sliding_window_minimum([1, 3, -1, -3, 5], 2) == [(1, 0), (-1, 2), (-3, 3), (-3, 3)]
assert sliding_window_minimum([10, 5, 2, 7, 8, 7], 3) == [(2, 2), (2, 2), (2, 2), (7, 3)]

##############