1class Solution {
2    public long maximumProduct(int[] nums, int m) {
3        long maxProduct = Long.MIN_VALUE;               // Variable to keep track of the maximum product
4        int maxInWindow = Integer.MIN_VALUE;            // Maximum number in the current sliding window
5        int minInWindow = Integer.MAX_VALUE;            // Minimum number in the current sliding window
6
7        // Iterate starting from the end of the first window (size m)
8        for (int i = m - 1; i < nums.length; ++i) {
9            int right = nums[i];                       // Current element (right end of the window)
10            int left = nums[i - m + 1];                // New leftmost element entering the window
11
12            // Update minInWindow and maxInWindow with the new left element
13            minInWindow = Math.min(minInWindow, left);
14            maxInWindow = Math.max(maxInWindow, left);
15
16            // Calculate possible products with min and max values, update maxProduct
17            long productWithMin = 1L * right * minInWindow;
18            long productWithMax = 1L * right * maxInWindow;
19            maxProduct = Math.max(maxProduct, Math.max(productWithMin, productWithMax));
20        }
21        return maxProduct;
22    }
23}
24

1#include <vector>
2#include <climits>
3using namespace std;
4
5class Solution {
6public:
7    long long maximumProduct(vector<int>& nums, int m) {
8        long long maxProduct = LLONG_MIN; // Tracks the answer (maximum product found)
9        int currMax = INT_MIN; // Largest value in the current window
10        int currMin = INT_MAX; // Smallest value in the current window
11
12        // Iterate through the array, considering every window of size m that ends at i
13        for (int i = m - 1; i < nums.size(); ++i) {
14            int rightmost = nums[i];                  // Current element at the end of the window
15            int leftmost = nums[i - m + 1];           // Current element at the start of the window
16
17            currMin = min(currMin, leftmost);         // Update current minimum in the window
18            currMax = max(currMax, leftmost);         // Update current maximum in the window
19
20            // Compute two possible products with min and max and update maxProduct
21            maxProduct = max(maxProduct, max(1LL * rightmost * currMin, 1LL * rightmost * currMax));
22        }
23        return maxProduct;
24    }
25};
26

1/**
2 * Finds the maximum product of any two numbers in the array,
3 * where the second number is within the last `m` elements before or at the current index.
4 * @param nums - Array of integers.
5 * @param m - The window size.
6 * @returns The maximum product found.
7 */
8function maximumProduct(nums: number[], m: number): number {
9    // Initialize the answer to the smallest possible safe integer.
10    let result = Number.MIN_SAFE_INTEGER;
11
12    // Track the minimum and maximum values within the current window.
13    let maxInWindow = Number.MIN_SAFE_INTEGER;
14    let minInWindow = Number.MAX_SAFE_INTEGER;
15
16    // Traverse the array, starting from index (m - 1) to ensure a full window.
17    for (let i = m - 1; i < nums.length; i++) {
18        const current = nums[i];                       // Current number.
19        const windowStart = nums[i - m + 1];           // Start of the current window (sliding).
20
21        // Update the minimum and maximum with the new window start value.
22        minInWindow = Math.min(minInWindow, windowStart);
23        maxInWindow = Math.max(maxInWindow, windowStart);
24
25        // Calculate product of the current number with the current min and max in the window.
26        // Update the result if a larger product is found.
27        result = Math.max(result, current * minInWindow, current * maxInWindow);
28    }
29
30    return result;
31}
32