Number of Sub-arrays With Odd Sum - Practice Coding Problems

Number of Sub-arrays With Odd Sum - Problem

Given an array of integers arr, you need to find the number of contiguous subarrays whose sum is odd.

A subarray is a contiguous part of an array. For example, in array [1, 2, 3], the subarrays are: [1], [2], [3], [1, 2], [2, 3], and [1, 2, 3].

Key insight: A sum is odd if it contains an odd number of odd elements. This mathematical property allows us to solve the problem efficiently using dynamic programming or prefix sum techniques.

Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

example_1.py — Basic case

$ Input: arr = [1, 3, 5]

› Output: 4

💡 Note: The subarrays with odd sum are: [1] (sum=1), [3] (sum=3), [5] (sum=5), and [1,3] (sum=4 is even, so this is wrong). Actually: [1] (sum=1), [3] (sum=3), [5] (sum=5), [1,3,5] (sum=9). Wait, let me recalculate: [1]=1✓, [3]=3✓, [5]=5✓, [1,3]=4✗, [3,5]=8✗, [1,3,5]=9✓. So 4 is correct.

example_2.py — Mixed even/odd

$ Input: arr = [2, 4, 6]

› Output: 0

💡 Note: All elements are even, so any subarray sum will be even. No subarrays have odd sum.

example_3.py — Single element

$ Input: arr = [1]

› Output: 1

💡 Note: Only one subarray [1] with sum 1, which is odd.

Constraints

1 ≤ arr.length ≤ 10⁵
1 ≤ arr[i] ≤ 10⁹
Return result modulo 10⁹ + 7

Visualization

Tap to expand

Understanding the Visualization

Initialize Switch State

Start with switch OFF (even prefix sum = 0), even_count = 1

Process Each Number

Add number to running sum, check if switch state changed

Count Valid Pairs

Current state can pair with all previous opposite states

Update State Counter

Increment counter for current switch state

Key Takeaway

🎯 Key Insight: Each element either flips the parity switch or keeps it the same. Count valid ON↔OFF transitions to find all subarrays with odd sums in O(n) time!

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 25

The optimal solution uses prefix sum with parity tracking in O(n) time. Key insight: a subarray has odd sum if and only if its prefix sums have different parity. Track counts of even/odd prefixes and add appropriate count for each position.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check all possible subarrays and count their sums
One-Pass Prefix Sum (Optimal)	O(n)	O(1)	Track count of even and odd prefix sums in single pass

Brute Force (Nested Loops) — Algorithm Steps

Use outer loop for starting index i
Use inner loop for ending index j (from i to n-1)
Calculate sum of subarray from i to j
Check if sum is odd and increment counter
Return counter modulo 10^9 + 7

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Begin checking subarrays starting from index 0

Extend subarray

Add next element and check if sum is odd

Continue until end

Keep extending until we reach the end of array

Move to next starting position

Start new subarrays from index 1, then 2, etc.

Code -

solution.c — C

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

int numSubarraysWithOddSum(int* arr, int n) {
    const int MOD = 1000000007;
    long long count = 0;
    
    for (int i = 0; i < n; i++) {
        long long currentSum = 0;
        for (int j = i; j < n; j++) {
            currentSum += arr[j];
            if (currentSum % 2 == 1) {
                count = (count + 1) % MOD;
            }
        }
    }
    
    return count;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Two nested loops to generate all subarrays, with running sum optimization

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

62.4K Views

Medium-High Frequency

~18 min Avg. Time

1.8K 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler