Subarray Product Less Than K

Subarray Product Less Than K - Problem

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

Note: Since the product can grow very large, you need to consider edge cases like zeros and negative numbers.

Input & Output

Example 1 — Basic Case

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

› Output: 8

💡 Note: Valid subarrays: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]. Each has product < 100.

Example 2 — All Valid

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

› Output: 0

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

Example 3 — Large k

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

› Output: 6

💡 Note: All possible subarrays: [1], [1], [1], [1,1], [1,1], [1,1,1]. All have product 1 < 10.

Constraints

1 ≤ nums.length ≤ 3 × 10⁴
1 ≤ nums[i] ≤ 1000
0 ≤ k ≤ 10⁶

Visualization

Tap to expand

Asked in

F Facebook 25 a Amazon 18 G Google 15

The key insight is using a sliding window approach where for each valid window ending at position right, there are exactly (right - left + 1) valid subarrays. Best approach is the sliding window with two pointers. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Check All Subarrays

⏱️ Time: O(n³) Space: O(1)

For each starting position, generate all subarrays beginning at that position and calculate their products. Count how many have product strictly less than k.

Sliding Window - Two Pointers

⏱️ Time: O(n) Space: O(1)

Maintain a sliding window with left and right pointers. Expand right when product is valid, shrink left when product becomes too large. For each valid window, count all subarrays ending at right pointer.

Brute Force - Check All Subarrays — Algorithm Steps

Iterate through each possible starting index
For each start, iterate through all possible ending indices
Calculate product of current subarray and increment count if < k

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

For each start position, generate all possible subarrays

Calculate Product

Multiply all elements in each subarray

Count Valid

Count subarrays with product < k

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    if (k <= 1) return 0;
    
    int count = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            int product = 1;
            for (int l = i; l <= j; l++) {
                product *= nums[l];
            }
            if (product < k) {
                count++;
            }
        }
    }
    
    return count;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int numsSize = 0;
    
    // Parse array using strtol
    char* p = line;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',' || *p == '\n') p++;
        if (*p == ']' || *p == '\0') break;
        
        nums[numsSize++] = (int)strtol(p, &p, 10);
    }
    
    int k;
    scanf("%d", &k);
    
    int result = solution(nums, numsSize, k);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Triple nested loops: n starting positions × n ending positions × n multiplications

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

✓ Linear Space

85.0K Views

Medium Frequency

~15 min Avg. Time

2.1K 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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler