Read-Optimized Duplicate Windows

You are given an integer array nums and a fixed window length k. Maintain an index that answers whether any requested contiguous window of length k contains equal values at two different positions.
Process operations in order. Every row contains three integers:
[0, index, value] replaces nums[index] with value.
[1, start, ignored] queries the window from start through start + k - 1, inclusive. Append 1 if that window contains a duplicate value, or 0 otherwise. The third integer is ignored.
Return the query results in encounter order. Updates produce no output. Every query sees all preceding updates and no later ones. The array length and k never change.
Optimize for a read-heavy workload: target O(1) work per query, O(n) work per update, and O(n) index space, where n = nums.length. Hash-table counting gives expected linear update time. Output storage is separate from index space.

Function
duplicateWindowQueries(nums: int[], k: int, operations: int[][]) → int[]

Examples
Example 1
nums = [1,2,1,3]
k = 3
operations = [[1,0,0],[1,1,0],[0,2,2],[1,0,0],[1,1,0],[0,1,4],[1,0,0]]
return = [1,0,1,1,0]
Initially [1,2,1] contains a duplicate, but [2,1,3] does not. Replacing index 2 with 2 makes both windows contain duplicate twos. Replacing index 1 with 4 makes the first window [1,4,2], which is distinct.
Example 2
nums = [4,5,6]
k = 3
operations = [[1,0,9],[0,2,4],[1,0,-8],[0,0,9],[1,0,7]]
return = [0,1,0]
There is one full-array window. Its values change from [4,5,6] to [4,5,4] and then [9,5,4]. The third field of each query has no effect.

Constraints
1 <= nums.length <= 1000
1 <= k <= nums.length
0 <= operations.length <= 300, and each row has exactly three integers.
Initial and replacement values are between -1000000 and 1000000.
Update indices satisfy 0 <= index < n; query starts satisfy 0 <= start <= n-k.
The ignored query field is any integer between -1000000 and 1000000.

Store a result array dup[s] for every valid window start s, which is n-k+1 entries. A query returns dup[start] in O(1). On each update, set nums[index] and recompute. The simple route: rebuild all window flags in O(n) using a sliding window with a hash map of counts and a running count of values with frequency above 1. Slide from start 0 to n-k, adding the right element and removing the left one, and record whether the duplicate counter is positive. That's O(n) time and O(n) space for dup plus the map. The pitfall is recomputing each window from scratch, which is O(n*k) per update and misses the target. Another trap is decrementing a count to 1 and forgetting to lower the duplicate counter. Remember the third field is ignored on queries, and updates append nothing. With 300 operations and n up to 1000, the rebuild approach is comfortably fast. If the live OA freezes your head, StealthCoder can hand you this structure as a hedge.

If you see this problem in your OA tomorrow, the play is to recognize the pattern in 30 seconds. StealthCoder buys you that recognition.