Count Subarrays Matching a Comparison Pattern

For this exercise, use the callable contract below.
You are given an integer array numbers and an integer array pattern containing only -1, 0, and 1.
Each pattern value describes one adjacent comparison:
1 means the next value is greater.
0 means the next value is equal.
-1 means the next value is smaller.
Return the number of contiguous subarrays of length pattern.length + 1 whose adjacent comparisons exactly match the complete pattern.

Function
countMatchingSubarrays(numbers: int[], pattern: int[]) → int

Examples
Example 1
numbers = [1,2,3,4,5,6]
pattern = [1,1]
return = 4
Every length-three window is strictly increasing, so all four candidate windows match.
Example 2
numbers = [1,4,4,1,3,5,5,3]
pattern = [1,0,-1]
return = 2
The windows [1,4,4,1] and [3,5,5,3] increase, stay equal, and then decrease.

Constraints
2 <= numbers.length <= 10^5
1 <= pattern.length < numbers.length
-10^9 <= numbers[i] <= 10^9
pattern[i] is -1, 0, or 1.

The trick: convert numbers into a difference array of length n-1, where each entry is the sign of numbers[i+1] - numbers[i]. Now the problem is counting occurrences of pattern inside that sign array. The brute force compares each window against the pattern, which is O(n*m) and can time out with n at 10^5 and a long pattern. Use KMP (prefix function) or Z-function for O(n+m). A rolling hash also works but KMP is safer, with no collisions to worry about. The common pitfalls are using subtraction without taking the sign, forgetting that equal values map to 0, and off-by-one on the window size. Check Example 1: 6 numbers give 5 signs, pattern length 2, so 4 matches. If the live OA makes you blank on KMP, StealthCoder can hand you the working solution while you keep control of the clock.

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