Sum of All Odd Length Subarrays - Problem

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

A subarray is a contiguous subsequence of the array.

For example, if arr = [1,4,2,5,3], the odd-length subarrays are:

Length 1: [1], [4], [2], [5], [3]
Length 3: [1,4,2], [4,2,5], [2,5,3]
Length 5: [1,4,2,5,3]

We need to sum all elements in all these subarrays.

Input & Output

Example 1 — Basic Case

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

› Output: 58

💡 Note: Odd-length subarrays: [1]=1, [4]=4, [2]=2, [5]=5, [3]=3, [1,4,2]=7, [4,2,5]=11, [2,5,3]=10, [1,4,2,5,3]=15. Sum = 1+4+2+5+3+7+11+10+15 = 58

Example 2 — Smaller Array

$ Input: arr = [1,2]

› Output: 3

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

Example 3 — Single Element

$ Input: arr = [10]

› Output: 10

💡 Note: Only one subarray [10] with odd length 1. Sum = 10

Constraints

1 ≤ arr.length ≤ 100
1 ≤ arr[i] ≤ 1000

Visualization

Tap to expand

Asked in

A Amazon 25 G Google 18 🍎 Apple 12

The key insight is that instead of generating all odd-length subarrays, we can mathematically calculate how many times each element appears in odd-length subarrays. The optimal approach uses combinatorics to determine each element's contribution in O(1) time. Best approach: Mathematical Formula with Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Generate All Odd Subarrays

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

For each possible starting position, generate all odd-length subarrays starting from that position. Sum all elements in each subarray and add to total.

Mathematical Formula

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

Instead of generating subarrays, mathematically determine how many odd-length subarrays contain each element. For element at index i, count how many ways to form odd subarrays that include it by choosing start and end positions.

Prefix Sum Optimization

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

Build a prefix sum array first, then for each starting position and odd length, use prefix sums to calculate subarray sum in constant time instead of iterating through elements.

Brute Force - Generate All Odd Subarrays — Algorithm Steps

Iterate through each starting position i
For each i, generate subarrays of odd lengths (1, 3, 5...)
Sum elements in each subarray and add to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Start Position

Pick starting index

Generate Subarrays

Create all odd-length subarrays from this position

Sum Elements

Add up all elements in each subarray

Code -

solution.c — C

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

int solution(int* arr, int n) {
    int totalSum = 0;
    
    // Try all starting positions
    for (int i = 0; i < n; i++) {
        // Try all odd lengths starting from position i
        for (int length = 1; length <= n - i; length += 2) {
            // Sum elements in current subarray
            int subarraySum = 0;
            for (int j = i; j < i + length; j++) {
                subarraySum += arr[j];
            }
            totalSum += subarraySum;
        }
    }
    
    return totalSum;
}

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[1000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array manually
    int arr[100];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            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³)

Three nested loops: outer for start position, middle for subarray length, inner for summing elements

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track sum and indices, no extra data structures

✓ Linear Space

98.5K Views

Medium Frequency

~15 min Avg. Time

2.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

Sum of All Odd Length Subarrays - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Odd Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler