Sort an Array with Rotate and Flip

You are given an array values containing distinct integers. You may apply either of these operations:
Rotate: Move the first element to the end of the array.
Flip: Reverse the entire array.
Return the minimum number of operations needed to place values in strictly increasing order. You may use the operations in any sequence. If increasing order cannot be reached, return -1.

Function
minSortOperations(values: int[]) → int

Examples
Example 1
values = [3,4,1,2]
return = 2
Rotate twice: [3,4,1,2] becomes [1,2,3,4]. No single operation produces increasing order.
Example 2
values = [3,2,1,4]
return = 2
Flip to obtain [4,1,2,3], then rotate once to obtain [1,2,3,4].
Example 3
values = [1,3,2,4]
return = -1
Rotations preserve the circular order, and a flip only reverses that order. Neither orientation can match [1,2,3,4], so sorting is impossible.

Constraints
1 <= values.length <= 200000
Every element is a 32-bit signed integer.
All elements are distinct.

Count circular descents. Exactly one descent (a[i] > a[(i+1) mod n]) means the array is a rotation of ascending order. Let k be the index of the minimum. Cost is min(k, n-k+2). Left rotate k times, or flip, rotate n-k, flip, which acts as a right rotation. Exactly one circular ascent means descending rotation. Let j be the index of the maximum. Cost is min(j, n-j)+1, since one flip plus rotations in whichever direction is cheaper. If neither holds, return -1. The pitfall is forgetting the two-flip trick for right rotation, which gives wrong answers when k is large. Also handle n=1 and n=2, where both shapes fit, so take the smaller cost. This runs in O(n). StealthCoder is the hedge in the live OA if you can't recall the direction logic under pressure.

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