Subarray Product Less Than K - Practice Coding Problems

Subarray Product Less Than K - Problem

Given an array of positive integers nums and an integer k, your task is to find the number of contiguous subarrays where the product of all elements in the subarray is strictly less than k.

A subarray is a contiguous sequence of elements within an array. For example, in array [1, 2, 3, 4], some subarrays include [1], [2, 3], [1, 2, 3], etc.

Key Points:

All numbers in the array are positive integers
We're looking for subarrays where the product (not sum) is less than k
The product must be strictly less than k (not equal to k)
Return the count of such subarrays, not the subarrays themselves

Input & Output

example_1.py — Basic Case

$ Input: nums = [10, 5, 2, 6], k = 100

› Output: 8

💡 Note: The 8 subarrays with product less than 100 are: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]. Note that [10,5,2] has product 100 which is not strictly less than k.

example_2.py — Single Element

$ Input: nums = [1, 2, 3], k = 0

› Output: 0

💡 Note: Since k = 0, no subarray can have a product strictly less than 0 (all elements are positive).

example_3.py — All Elements Valid

$ Input: nums = [1, 1, 1], k = 2

› Output: 6

💡 Note: All possible subarrays have product 1 < 2: [1], [1], [1], [1,1], [1,1], [1,1,1]. Total = 6.

Visualization

Tap to expand

Understanding the Visualization

Start Shopping

Begin with an empty cart (left = right = 0)

Add Items

Add items to cart (expand window) while total cost < k

Remove Items

When over budget, remove items from left side of cart

Count Combinations

For each valid cart state, count all possible subcombinations

Key Takeaway

🎯 Key Insight: Use sliding window technique where each valid window of size n contributes n new subarrays, achieving O(n) efficiency instead of O(n²) brute force.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop runs n times, inner loop runs up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track indices and product

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
1 ≤ nums[i] ≤ 1000
0 ≤ k ≤ 10⁶
All elements in nums are positive integers

Asked in

a Amazon 45 G Google 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a sliding window (two pointers) approach with O(n) time complexity. The key insight is that when we have a valid window of size n, it contributes exactly n new subarrays ending at the current right position. We expand the window when the product is less than k and contract it when the product exceeds or equals k.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible subarray by trying all start and end positions
Sliding Window (Two Pointers)	O(n)	O(1)	Use expanding and contracting window to efficiently count valid subarrays

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each possible starting position i
For each starting position, iterate through ending positions j from i onwards
Calculate the product of elements from i to j
If product < k, increment the counter
Continue until we've checked all subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Begin checking subarrays starting from index 0

Extend subarray

Add elements one by one and calculate product

Check condition

If product < k, count this subarray

Move to next start

Repeat process for next starting position

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int numSubarrayProductLessThanK(int* nums, int numsSize, int k) {
    if (k <= 1) return 0;
    
    int count = 0;
    
    // Try all possible starting positions
    for (int i = 0; i < numsSize; i++) {
        int product = 1;
        // Try all ending positions from current start
        for (int j = i; j < numsSize; j++) {
            product *= nums[j];
            // If product exceeds k, no point in extending further
            if (product >= k) break;
            count++;
        }
    }
    
    return count;
}

int main() {
    int nums[] = {10, 5, 2, 6};
    int k = 100;
    printf("%d\n", numSubarrayProductLessThanK(nums, 4, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops: outer loop runs n times, inner loop runs up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track indices and product

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
1 ≤ nums[i] ≤ 1000
0 ≤ k ≤ 10⁶
All elements in nums are positive integers

42.0K Views

High Frequency

~18 min Avg. Time

1.6K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler