Minimum Operations for a Stepwise Sequence

You are given an integer array structures, where structures[i] is the height of the ith structure in a row.
In one operation, you may increase the height of any one structure by exactly 1. You cannot decrease a height.
Transform the array into either of these stepwise patterns:
Ascending: each height is exactly 1 greater than the height immediately before it.
Descending: each height is exactly 1 less than the height immediately before it.
Return the minimum number of operations required to form either pattern.

Function
solution(structures: int[]) → long

Examples
Example 1
structures = [1,4,3,2]
return = 4
Add 4 units to the first structure. The final heights are [5,4,3,2], which form a descending stepwise pattern. Therefore, the minimum number of operations is 4.
Example 2
structures = [5,7,9,4,11]
return = 9
Add 2 units to the first structure, 1 unit to the second structure, and 6 units to the fourth structure. The final heights are [7,8,9,10,11], which form an ascending stepwise pattern. The total is 2 + 1 + 6 = 9 operations.

Both patterns are fully determined by one number, the starting height. For ascending, structure i must end at s + i. Each element needs s + i >= structures[i], so s must be at least max(structures[i] - i). Cost grows with s, so pick the smallest valid s. Descending works the same way with s - i, so s must be at least max(structures[i] + i). Then sum (target - original) for each pattern and return the smaller. That's O(n). The pitfall is the edge case: a naive solution anchors on structures[0] and ignores that a later tall structure forces the whole sequence up. Example 1 shows it, since the 4 in position 1 drags the descending start to 5. Use a 64-bit sum, because the return type is long. If you freeze during the live OA, StealthCoder is the hedge that surfaces this max-offset approach.

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