Given an array of positive integers `nums` and an integer `T`, return the number of contiguous subarrays whose product is strictly less than `T`. Your algorithm should run in `O(n)` time and use `O(1)` extra space beyond the input. Important edge cases: - If `T <= 1`, the answer is `0` because every subarray product of positive integers is at least `1`. - Arrays may contain `1`s. This does not break the sliding-window approach, but it means the product may stay the same when the window expands. Why a sliding window works: because all numbers are positive, multiplying by a new right-end element can only keep the product the same or increase it, and moving the left end rightward can only keep the product the same or decrease it. So we can maintain the smallest valid window ending at each position. If the current valid window is `nums[left:right+1]`, then every subarray ending at `right` and starting anywhere from `left` to `right` is also valid, contributing `right - left + 1` new subarrays.

def solution(nums, T):
    if T <= 1:
        return 0

    left = 0
    product = 1
    count = 0

    for right in range(len(nums)):
        product *= nums[right]

        while left <= right and product >= T:
            product //= nums[left]
            left += 1

        count += right - left + 1

    return count