Sum of All Odd Length Subarrays - Practice Coding Problems

Sum of All Odd Length Subarrays - Problem

Given an array of positive integers arr, calculate the sum of all possible odd-length subarrays.

A subarray is a contiguous sequence of elements from the original array. For example, in array [1, 4, 2, 5, 3], the subarrays of length 1 are [1], [4], [2], [5], [3], the subarrays of length 3 are [1,4,2], [4,2,5], [2,5,3], and the subarray of length 5 is [1,4,2,5,3].

Your task: Find all subarrays with odd lengths (1, 3, 5, 7, ...), calculate the sum of each subarray, then return the total sum of all these sums.

Example: For arr = [1,4,2,5,3]:
• Length 1: [1], [4], [2], [5], [3] → sum = 15
• Length 3: [1,4,2], [4,2,5], [2,5,3] → sum = 7+11+10 = 28
• Length 5: [1,4,2,5,3] → sum = 15
• Total: 15 + 28 + 15 = 58

Input & Output

example_1.py — Basic Case

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

› Output: 58

💡 Note: Length 1: [1]+[4]+[2]+[5]+[3] = 15. Length 3: [1,4,2]+[4,2,5]+[2,5,3] = 7+11+10 = 28. Length 5: [1,4,2,5,3] = 15. Total: 15+28+15 = 58.

example_2.py — Small Array

$ Input: [1,2]

› Output: 3

💡 Note: Only odd-length subarrays are of length 1: [1] and [2]. Sum = 1 + 2 = 3.

example_3.py — Single Element

$ Input: [10,11,12]

› Output: 66

💡 Note: Length 1: [10]+[11]+[12] = 33. Length 3: [10,11,12] = 33. Total: 33+33 = 66.

Constraints

1 ≤ arr.length ≤ 100
1 ≤ arr[i] ≤ 1000
All integers in the array are positive

Visualization

Tap to expand

Understanding the Visualization

Identify positions

Each book (element) has a fixed position on the shelf

Count groupings

Calculate how many odd-sized groups can include each specific book

Apply formula

Use mathematical insight: (total_groups + 1) ÷ 2 gives odd-sized groups

Key Takeaway

🎯 Key Insight: Rather than generating all subarrays, we calculate each element's contribution mathematically. Each element appears in a predictable number of odd-length subarrays based on its position, leading to an elegant O(n) solution.

Asked in

a Amazon 15 ⊞ Microsoft 8 G Google 6 Apple 4

The optimal solution uses a mathematical formula to calculate how many odd-length subarrays contain each element. For element at index i, we count (left+1) × (right+1) total subarrays, then use ceiling division to find odd-length count. This achieves O(n) time complexity without generating actual subarrays.

Common Approaches

Approach	Time	Space	Notes
✓ Mathematical Formula (Optimal)	O(n)	O(1)	Calculate contribution of each element using mathematical formula

Mathematical Formula (Optimal) — Algorithm Steps

For each element at position i, calculate how many elements are to its left and right
Count total subarrays containing this element: (left + 1) × (right + 1)
Count odd-length subarrays: use ceiling division to count odd combinations
Multiply element value by its contribution count and add to total

Visualization

Tap to expand

Step-by-Step Walkthrough

Count subarrays containing each element

For element at index i: (left+1) × (right+1) total subarrays

Calculate odd-length subarrays

Use formula: (total + 1) / 2 to get odd-length count

Multiply by element value

Each element contributes value × odd_subarray_count to final sum

Code -

solution.c — C

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

int sumOddLengthSubarrays(int* arr, int n) {
    int totalSum = 0;
    
    for (int i = 0; i < n; i++) {
        // Count elements to left and right of current element
        int left = i;
        int right = n - i - 1;
        
        // Total subarrays containing arr[i]
        int totalSubarrays = (left + 1) * (right + 1);
        
        // Number of odd-length subarrays containing arr[i]
        int oddSubarrays = (totalSubarrays + 1) / 2;
        
        // Add contribution of current element
        totalSum += arr[i] * oddSubarrays;
    }
    
    return totalSum;
}

int main() {
    char input[1000];
    fgets(input, 1000, stdin);
    
    // Simple parsing for [1,2,3] format
    int arr[100];
    int n = 0;
    char* token = input + 1; // Skip '['
    
    while (*token && *token != ']') {
        while (*token == ' ' || *token == ',') token++;
        if (*token >= '0' && *token <= '9') {
            arr[n++] = atoi(token);
            while (*token >= '0' && *token <= '9') token++;
        } else {
            token++;
        }
    }
    
    printf("%d\n", sumOddLengthSubarrays(arr, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through array to calculate each element's contribution

✓ Linear Growth

Space Complexity

O(1)

Only using variables to store calculations, no additional data structures

✓ Linear Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 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

Mathematical Formula (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler