• 1 <= nums.length <= 10⁴
• -10⁹ <= nums[i] <= 10⁹

Same question as the plain next-greater problem — for each number, find the first larger number to its right — except the array is a circle: after the last element you wrap around to the front, so even the final element gets to look at everything before it. A number gets -1 only if nothing in the entire circle beats it.

The engine here is a monotonic stack: a normal stack (push/pop at one end) that we deliberately keep in decreasing order of value. The idea is that we hold the numbers still waiting for a bigger neighbor, and the moment a bigger number arrives it resolves them. Why does the stack stay decreasing? Because any waiting number is removed the instant something larger passes it, so a bigger newcomer can never sit on top of a smaller old-timer — it would have popped it first. We store indices, not values, since the answer is position-based and the array can contain duplicates.

To handle the wrap-around without actually copying the array, walk an index i from 0 to 2N - 1 and read nums[i % N], which replays the array twice. The two laps play different roles:
- First lap (i < N): business as usual — while the current value beats the value at the top index, that top index just found its next-greater; pop and record it. Then push the current index to wait.
- Second lap (i >= N): do not push anything new. Every index already had its turn as a waiter in the first lap; the replay exists only so leftover waiters from the tail can finally see the values sitting at the front of the array.

One extra lap is enough: after seeing every other element in the circle, a number that still hasn't been beaten genuinely has no next-greater, so it keeps its -1.

# Monotonic Stack over two laps (O(N) Time, O(N) Space)
n = len(nums)
res = [-1] * n
stack = []                       # holds indices; values kept decreasing

for i in range(2 * n):
    cur = nums[i % n]
    while stack and cur > nums[stack[-1]]:
        res[stack.pop()] = cur   # this waiting index found its next-greater
    if i < n:                    # only the first lap enrolls new waiters
        stack.append(i)

return res

Each index is pushed once and popped once over the 2N steps, so the whole thing is linear despite the inner loop.

Flip the comparison to < and keep the stack increasing and the exact same machinery finds each element's next smaller number instead.