3904. Smallest Stable Index II

class Solution {
    public int firstStableIndex(int[] nums, int k) {
        int n = nums.length;
        int[] prefixMax = new int[n];
        prefixMax[0] = nums[0];
        for (int i = 1; i < n; i++) {
            prefixMax[i] = Math.max(prefixMax[i - 1], nums[i]);
        }
        int[] suffixMin = new int[n];
        suffixMin[n - 1] = nums[n - 1];
        for (int i = n - 2; i >= 0; i--) {
            suffixMin[i] = Math.min(suffixMin[i + 1], nums[i]);
        }
        for (int i = 0; i < n; i++) {
            int instability = prefixMax[i] - suffixMin[i];
            if (instability <= k) {
                return i;
            }
        }
        return -1;
    }
}

class Solution:
    def firstStableIndex(self, nums, k):
        n = len(nums)

        prefixMax = [0] * n
        prefixMax[0] = nums[0]

        for i in range(1, n):
            prefixMax[i] = max(prefixMax[i - 1], nums[i])

        suffixMin = [0] * n
        suffixMin[n - 1] = nums[n - 1]

        for i in range(n - 2, -1, -1):
            suffixMin[i] = min(suffixMin[i + 1], nums[i])

        for i in range(n):
            instability = prefixMax[i] - suffixMin[i]

            if instability <= k:
                return i

        return -1

class Solution {
public:
    int firstStableIndex(vector<int>& nums, int k) {
        int n = nums.size();

        vector<int> prefixMax(n);
        prefixMax[0] = nums[0];

        for (int i = 1; i < n; i++) {
            prefixMax[i] = max(prefixMax[i - 1], nums[i]);
        }

        vector<int> suffixMin(n);
        suffixMin[n - 1] = nums[n - 1];

        for (int i = n - 2; i >= 0; i--) {
            suffixMin[i] = min(suffixMin[i + 1], nums[i]);
        }

        for (int i = 0; i < n; i++) {
            int instability = prefixMax[i] - suffixMin[i];

            if (instability <= k) {
                return i;
            }
        }

        return -1;
    }
};

class Solution {
    firstStableIndex(nums, k) {
        const n = nums.length;

        const prefixMax = new Array(n);
        prefixMax[0] = nums[0];

        for (let i = 1; i < n; i++) {
            prefixMax[i] = Math.max(
                prefixMax[i - 1],
                nums[i]
            );
        }

        const suffixMin = new Array(n);
        suffixMin[n - 1] = nums[n - 1];

        for (let i = n - 2; i >= 0; i--) {
            suffixMin[i] = Math.min(
                suffixMin[i + 1],
                nums[i]
            );
        }

        for (let i = 0; i < n; i++) {
            const instability = prefixMax[i] - suffixMin[i];

            if (instability <= k) {
                return i;
            }
        }

        return -1;
    }
}