Number of Sub-arrays With Odd Sum - Problem

Given an array of integers arr, return the number of subarrays with an odd sum.

A subarray is a contiguous part of an array. Since the answer can be very large, return it modulo 10⁹ + 7.

Input & Output

Example 1 — Basic Case

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

› Output: 4

💡 Note: All odd-sum subarrays: [1] (sum=1), [3] (sum=3), [5] (sum=5), and [1,3,5] (sum=9). Total count = 4.

Example 2 — Mixed Numbers

$ 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 — Single Element

$ Input: arr = [1]

› Output: 1

💡 Note: Only one subarray [1] with sum=1 (odd). Count = 1.

Constraints

1 ≤ arr.length ≤ 10⁵
0 ≤ arr[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 f Facebook 20 a Amazon 15 M Microsoft 12

The key insight is that a subarray has an odd sum if and only if its starting and ending prefix sums have different parities. By tracking counts of odd and even prefix sums encountered, we can count valid subarrays in O(n) time. Best approach uses prefix sum parity counting. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Check All Subarrays

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

For each starting position, check all possible ending positions and calculate the sum of each subarray. Count how many have odd sums.

Optimal - Prefix Sum Pattern

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

A subarray has odd sum if and only if its prefix sums have different parities (one odd, one even). Track counts of odd and even prefix sums encountered so far.

Optimized - Running Sum

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

Instead of recalculating sums from scratch, maintain a running sum as we extend each subarray. This eliminates the innermost loop.

Brute Force - Check All Subarrays — Algorithm Steps

Step 1: For each starting index i
Step 2: For each ending index j >= i
Step 3: Calculate sum from i to j and check if odd

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All Subarrays

Create every possible contiguous subarray

Calculate Sum

Add up elements in each subarray

Count Odd Sums

Increment counter if sum is odd

Code -

solution.c — C

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

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

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[100000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int arr[10000];
    int n = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        arr[n++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int result = solution(arr, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Triple nested loops: n starting positions × n ending positions × n sum calculations

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track count and current sum

✓ Linear Space

78.0K Views

Medium Frequency

~25 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

Number of Sub-arrays With Odd Sum - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler