Number of Subarrays Having Even Product - Practice Coding Problems

Number of Subarrays Having Even Product - Problem

Given a 0-indexed integer array nums, your task is to find and return the number of subarrays whose product of all elements is even.

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

The product of a subarray is even if it contains at least one even number, since any number multiplied by an even number results in an even product.

Goal: Count all possible subarrays with even products efficiently.

Input & Output

example_1.py — Basic Case

$ Input: [2,1,3,4]

› Output: 7

💡 Note: The subarrays with even products are: [2], [2,1], [2,1,3], [2,1,3,4], [1,3,4], [3,4], [4]. All contain at least one even number, making their products even.

example_2.py — All Odd Numbers

$ Input: [1,3,5]

› Output: 0

💡 Note: All numbers are odd, so every subarray contains only odd numbers. The product of odd numbers is always odd, resulting in 0 subarrays with even products.

example_3.py — All Even Numbers

$ Input: [2,4,6]

› Output: 6

💡 Note: All numbers are even, so every possible subarray has an even product. Total subarrays = n*(n+1)/2 = 3*4/2 = 6: [2], [4], [6], [2,4], [4,6], [2,4,6].

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
Note: Numbers can be very large, but we only care about their parity (odd/even)

Visualization

Tap to expand

Understanding the Visualization

Identify Plain Cookie Segments

Scan the conveyor belt and mark consecutive plain cookies (odd numbers)

Count Segment Groups

For each plain cookie segment of length k, it contains k*(k+1)/2 possible groups

Sum All Plain Groups

Add up all the plain cookie groups from all segments

Calculate Premium Groups

Total possible groups minus plain groups equals premium groups (with chocolate chips)

Key Takeaway

🎯 Key Insight: Rather than checking every possible group for chocolate chips, we efficiently count the rare 'all plain' groups and subtract from the total. This mathematical approach transforms an O(n³) problem into an elegant O(n) solution!

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a clever mathematical approach: instead of counting subarrays with even products directly, we count subarrays with odd products (containing only odd numbers) and subtract from the total. This reduces the problem to finding consecutive odd number segments and applying the formula k*(k+1)/2 for each segment of length k. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Optimal: Count Odd-Product Subarrays	O(n)	O(1)	Count subarrays with all odd numbers, then subtract from total possible subarrays
Brute Force (Check Every Subarray)	O(n³)	O(1)	Generate all possible subarrays and check if each contains at least one even number

Optimal: Count Odd-Product Subarrays — Algorithm Steps

Calculate total possible subarrays: n*(n+1)/2
Iterate through array, counting consecutive odd numbers
When we hit an even number or end of array, calculate subarrays in current odd segment
Add segment's subarray count to total odd-product subarrays
Reset odd count and continue
Return total subarrays minus odd-product subarrays

Visualization

Tap to expand

Step-by-Step Walkthrough

Identify odd segments

Find consecutive sequences of odd numbers

Calculate segment subarrays

For k consecutive odds: k*(k+1)/2 subarrays

Sum all odd subarrays

Total subarrays with odd product

Subtract from total

Total - Odd = Even product subarrays

Code -

solution.c — C

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

long long countSubarraysWithEvenProduct(int* nums, int n) {
    long long totalSubarrays = (long long) n * (n + 1) / 2;
    
    long long oddSubarrays = 0;
    int oddCount = 0;
    
    for (int i = 0; i < n; i++) {
        if (nums[i] % 2 == 1) {  // Odd number
            oddCount++;
        } else {  // Even number
            // Add subarrays from current odd segment
            oddSubarrays += (long long) oddCount * (oddCount + 1) / 2;
            oddCount = 0;
        }
    }
    
    // Handle remaining odd segment at the end
    oddSubarrays += (long long) oddCount * (oddCount + 1) / 2;
    
    return totalSubarrays - oddSubarrays;
}

int main() {
    int nums[1000];
    int n = 0;
    char c;
    scanf("%c", &c); // skip '['
    while (scanf("%d%c", &nums[n], &c) == 2) {
        n++;
        if (c == ']') break;
    }
    printf("%lld\n", countSubarraysWithEvenProduct(nums, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array, each element processed once

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables for counting, no additional data structures

✓ Linear Space

28.2K Views

Medium Frequency

~15 min Avg. Time

847 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

Optimal: Count Odd-Product Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler