impl Solution {
    pub fn count_subarrays(nums: Vec<i32>, min_k: i32, max_k: i32) -> i64 {
        // Early return if the fixed bounds are invalid
        if min_k > max_k {
            return 0;
        }

        // Helper closure to check if a value is within the [min_k, max_k] range
        let in_bounds = |value: i32| (min_k..=max_k).contains(&value);

        // Split nums into chunks where elements are consistently either in or out of range
        nums.chunk_by(|&a, &b| in_bounds(a) == in_bounds(b))
            // Count fixed-bound subarrays within each valid chunk
            .map(|chunk| Self::count_fixed_bound_subarrays(chunk, min_k, max_k))
            // Sum the counts across all chunks
            .sum::<usize>() as i64
    }

    // Counts the number of fixed-bound subarrays inside a valid chunk
    fn count_fixed_bound_subarrays(chunk: &[i32], min_k: i32, max_k: i32) -> usize {
        let mut min_k_index = None;
        let mut max_k_index = None;

        chunk.iter().enumerate().map(|(index, &value)| {
            // Update the most recent positions of min_k and max_k
            if value == min_k {
                min_k_index = Some(index);
            }
            if value == max_k {
                max_k_index = Some(index);
            }

            // The number of valid subarrays ending at `index`
            match (min_k_index, max_k_index) {
                (Some(min_idx), Some(max_idx)) => min_idx.min(max_idx) + 1,
                _ => 0,
            }
        }).sum()
    }
}