Max Element Indexes After Rotations

You are given an array a of distinct positive integers and an array rotate. For each value in rotate, perform that many left circular rotations on the original array a, not on the result of any previous query.
Return an array where each element is the 0-based index of the maximum value in a after the corresponding number of left circular rotations.

Function
getMaxElementIndexes(a: int[], rotate: int[]) → int[]

Examples
Example 1
a = [1, 2, 3]
rotate = [1, 2, 3, 4]
return = [1,0,2,1]
After one left rotation, the array is [2,3,1], so the maximum value 3 is at index 1. The other rotation counts produce maximum indexes 0, 2, and 1.

Constraints
1 <= a.length <= 105
1 <= rotate.length <= 105
0 <= rotate[i] <= 105
All values in a are distinct positive integers.

The trick: find the index p of the maximum in the original array once. After k left rotations, an element at index p moves to (p - k) mod n. That's the whole answer for each query, so total work is O(n + m). The pitfall is the edge case. In most languages, (p - k) % n goes negative when k > p, so you need ((p - k) % n + n) % n. Also reduce k mod n, since rotate[i] can be far larger than n, and rotate[i] = 0 must return p unchanged. Don't simulate rotations, and don't chain them: each query starts from the original array. Check example 1: p = 2, n = 3, k = 1 gives 1, k = 2 gives 0, k = 3 gives 2, k = 4 gives 1. Matches. If the modulo sign trips you mid-assessment, StealthCoder is the hedge that gives you the correct expression fast.

The honest play: practice the pattern, and have StealthCoder ready for the one you didn't see coming.