Count Sortable Splits

You are given an integer array A of length N.
Choose one split position that divides A into two non-empty contiguous parts, called left and right. Sort the elements in each part independently in non-decreasing order, then join the sorted left part followed by the sorted right part.
Return the number of split positions for which the joined array is sorted in non-decreasing order.

Function
solution(A: int[]) → int

Examples
Example 1
A = [1, 3, 2, 4]
return = 2
There are three possible split positions:
left = [1] and right = [3, 2, 4] produce [1, 2, 3, 4], so this split works.
left = [1, 3] and right = [2, 4] produce [1, 3, 2, 4], so this split does not work.
left = [1, 3, 2] and right = [4] produce [1, 2, 3, 4], so this split works.
Therefore, the answer is 2.

Here's the reduction. After sorting both parts, the joined array is sorted exactly when max(left) <= min(right). Each part is already sorted internally, so the only possible violation is at the seam. Build a prefix max array and a suffix min array in two linear passes. Then for each split index i from 1 to N-1, count it if prefixMax[i-1] <= suffixMin[i]. That's O(N) time and O(N) space. The common pitfall is sorting both halves for every split, which is O(N^2 log N) and will time out on large inputs. Another trap is using strict less-than. Duplicates are allowed because the target is non-decreasing, so use <=. Also remember both parts must be non-empty, so splits run from 1 to N-1. If the live OA freezes your brain, StealthCoder is the hedge that keeps you moving.

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