You are given an integer array nums and an integer k.

Your task is to rotate only the non-negative elements of the array to the left by k positions, in a cyclic manner. This means that when an element goes past the beginning of the sequence of non-negative elements, it wraps around to the end.

There are some important rules to follow:

• All negative elements must stay in their original positions and must not move at all.
• After rotating the non-negative elements, you place them back into the array in their new order, filling only the positions that originally contained non-negative values and skipping all positions that contain negative values.

In other words, imagine you pull out all the non-negative numbers (keeping their relative order), rotate just that collected sequence to the left by k steps cyclically, and then drop them back into the array one by one into the slots that previously held non-negative numbers. The slots that held negative numbers remain untouched.

Return the resulting array after performing this operation.

Example walkthrough of the idea:

• Suppose nums = [3, -1, 5, -2, 7] and k = 1.
• The non-negative elements are [3, 5, 7].
• Rotating [3, 5, 7] to the left by 1 gives [5, 7, 3].
• Now place them back into the non-negative positions (indices 0, 2, and 4), keeping the negative elements (indices 1 and 3) in place.
• The result is [5, -1, 7, -2, 3].

The key observation is that the negative elements act like fixed anchors — they never move. Only the non-negative elements participate in the rotation. This naturally suggests separating the two groups: deal with the non-negative elements on their own, and leave the negative ones exactly where they are.

So the first idea is to extract all the non-negative elements into a separate list t, preserving their original relative order. Now the problem reduces to a simple, classic task: rotate this list t to the left by k positions cyclically.

For a left rotation by k, the element originally at index i should move to a new index. If we shift left by k, the element at position i ends up at position i - k. Since the rotation is cyclic, we take this index modulo m (where m is the number of non-negative elements). Because i - k can be negative, we use ((i - k) % m + m) % m to safely wrap it into the valid range [0, m - 1]. We store the rotated result in an array d.

Finally, we need to put these rotated values back. We walk through the original nums array one position at a time. Whenever we hit a position that originally held a non-negative value, we fill it with the next value from d (using a pointer j that advances each time). When we hit a negative value, we skip it and leave it untouched. This guarantees the negatives stay in place while the non-negatives are placed back in their new rotated order, exactly as the problem requires.

Solution 1: Simulation

We simulate the process directly by separating the non-negative elements, rotating them, and putting them back.

Step 1: Extract the non-negative elements.

We iterate through nums and collect every element that is >= 0 into a new list t, keeping their original relative order.

t = [x for x in nums if x >= 0]
m = len(t)

Here m is the number of non-negative elements, which is also the length of the cycle we rotate within.

Step 2: Rotate the elements into a result list d.

We create an array d of size m. For each element t[i], a left rotation by k means it should land at index i - k. Because the rotation is cyclic and i - k may be negative, we normalize the index with ((i - k) % m + m) % m to guarantee it falls within [0, m - 1].

d = [0] * m
for i, x in enumerate(t):
    d[((i - k) % m + m) % m] = x

After this loop, d holds the non-negative elements in their final rotated order.

Step 3: Place the rotated elements back into nums.

We scan through the original nums with a pointer j initialized to 0. Whenever we encounter a position that originally held a non-negative value, we overwrite it with d[j] and advance j. Negative values are skipped entirely, so they remain in their original positions.

j = 0
for i, x in enumerate(nums):
    if x >= 0:
        nums[i] = d[j]
        j += 1
return nums

Data structures and patterns used:

• Auxiliary arrays (t and d) to isolate and reorder only the non-negative elements.
• Modular arithmetic (((i - k) % m + m) % m) to handle the cyclic left rotation safely, even when k is larger than m or the index becomes negative.
• A two-pass scan with a pointer to map the rotated values back onto the correct slots while preserving the negative anchors.

Complexity Analysis:

• Time complexity: O(n), where n is the length of nums. We make a constant number of passes over the array.
• Space complexity: O(n), for the auxiliary arrays t and d that store the non-negative elements.