Open in App
Not now

# Find the sum of medians of all odd length subarrays

• Difficulty Level : Medium
• Last Updated : 14 Jan, 2022

Given an array arr[] of size N, the task is to find the sum of medians of all sub-array of odd-length.

Examples:

Input: arr[] = {4, 2, 5, 1}
Output: 18
Explanation : Sub-Arrays of odd length and their medians are :

• [4]  -> Median is 4
• [4, 2, 5]  -> Median is 4
• [2]  -> Median is 2
• [2, 5, 1]  -> Median is 2
• [5]  -> Median is 5
• [1]  -> Median is 1

Their sum = 4 + 4+ 2 + 2 + 5 +1 = 18

Input: arr[] = {1, 2}
Output: 3

Pre-requisites: Median of Stream of Running Integers using STL

Naive Approach: Generate each and every sub-array. If the length of the sub-array is odd, then sort the sub-array and return the middle element.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find sum of medians` `// of all odd-length subarrays` `int` `solve(vector<``int``> arr) ` `{` `    ``int` `ans = 0;` `    ``int` `n = arr.size();`   `    ``// Loop to calculate the sum` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{` `        ``vector<``int``> new_arr;` `        ``for``(``int` `j = i; j < n; j++) ` `        ``{` `            ``new_arr.push_back(arr[j]);` `            `  `            ``// Odd length subarray` `            ``if` `((new_arr.size() % 2) == 1)` `            ``{` `                ``sort(new_arr.begin(), new_arr.end());` `                ``int` `mid = new_arr.size() / 2;` `                ``ans += new_arr[mid];` `            ``}` `        ``}` `    ``}` `    ``return` `ans;` `}`   `// Driver Code` `int` `main() ` `{` `    ``vector<``int``> arr = { 4, 2, 5, 1 };` `    ``cout << solve(arr);` `}`   `// This code is contributed by Samim Hossain Mondal.`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG {` `    ``// Function to find sum of medians` `    ``// of all odd-length subarrays` `    ``static` `int` `solve(``int``[] arr) {` `        ``int` `ans = ``0``;` `        ``int` `n = arr.length;`   `        ``// Loop to calculate the sum` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``List new_arr = ``new` `LinkedList();` `            ``for` `(``int` `j = i; j < n; j++) {` `                ``new_arr.add(arr[j]);`   `                ``// Odd length subarray` `                ``if` `((new_arr.size() % ``2``) == ``1``) {` `                    ``Collections.sort(new_arr);` `                    ``int` `mid = new_arr.size() / ``2``;` `                    ``ans += new_arr.get(mid);` `                ``}` `            ``}` `        ``}` `        ``return` `ans;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = { ``4``, ``2``, ``5``, ``1` `};` `        ``System.out.println(solve(arr));` `    ``}` `}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python program for the above approach`   `# Function to find sum of medians` `# of all odd-length subarrays` `def` `solve(arr):` `        ``ans ``=` `0` `        ``n ``=` `len``(arr)` `        `  `        ``# Loop to calculate the sum` `        ``for` `i ``in` `range``(n):` `            ``new_arr ``=` `[]` `            ``for` `j ``in` `range``(i, n, ``1``):` `                ``new_arr.append(arr[j])`   `                ``# Odd length subarray` `                ``if` `(``len``(new_arr)) ``%` `2` `=``=` `1``:` `                    ``new_arr.sort()` `                    ``mid ``=` `len``(new_arr)``/``/``2` `                    ``ans ``+``=` `new_arr[mid]` `        ``return` `(ans)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``4``, ``2``, ``5``, ``1``]` `    ``print``(solve(arr))` `   `

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG` `{`   `  ``// Function to find sum of medians` `  ``// of all odd-length subarrays` `  ``static` `int` `solve(``int``[] arr) {` `    ``int` `ans = 0;` `    ``int` `n = arr.Length;`   `    ``// Loop to calculate the sum` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``List<``int``> new_arr = ``new` `List<``int``>();` `      ``for` `(``int` `j = i; j < n; j++) {` `        ``new_arr.Add(arr[j]);`   `        ``// Odd length subarray` `        ``if` `((new_arr.Count % 2) == 1) {` `          ``new_arr.Sort();` `          ``int` `mid = new_arr.Count / 2;` `          ``ans += new_arr[mid];` `        ``}` `      ``}` `    ``}` `    ``return` `ans;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main() {` `    ``int``[] arr = { 4, 2, 5, 1 };` `    ``Console.Write(solve(arr));` `  ``}` `}`   `// This code is contributed by Saurabh Jaiswal`

## Javascript

 ``

Output

`18`

Time Complexity: O(N3 * Log(N))
Auxiliary Space: O(N)

Note: Instead of sorting array each time, which costs (N*logN), insertion sort can be applied. But still, overall Time Complexity will be O(N3).

Efficient Approach: The median of the sorted array is the value separating the higher half from the lower half in the array. For finding out the median, we only need the middle element, rather than the entire sorted array. The approach of Median of Stream of Running Integers can be applied over here. Follow the steps mentioned below

1. Use max and min heaps to calculate the running median.
2. Traverse each and every element in the array.
3. While creating a new subarray, add an element into the heaps and return median if the size is odd else return 0.
4. Max_heap is used to store lower half elements such that the maximum element is at the top and min_heap is used to store higher half elements such that the minimum element is at the top.
5. The difference between both the heaps should not be greater than one, and one extra element is always placed in max_heap.

Note: Here max_heap is implemented using min_heap, by just negating the values so that the maximum negative element can be popped.

Below is the implementation of the above approach:

## Python3

 `# Python program for the above approach` `from` `heapq ``import` `heappush as push, heappop as pop`   `# Find the sum of medians of odd-length` `# subarrays`     `class` `find_median():`   `    ``# Constructor to declare two heaps` `    ``def` `__init__(``self``):`   `        ``# Store lower half elements such that ` `        ``# maximum element is at top` `        ``self``.max_heap ``=` `[]`   `        ``# Store higher half elements such that ` `        ``# minimum element is at top` `        ``self``.min_heap ``=` `[]`   `    ``def` `add(``self``, val):`   `        ``# len(max_heap) == 0 or curr_element ` `        ``# smaller than max_heap top` `        ``if` `(``len``(``self``.max_heap) ``=``=` `0` `or` `            ``self``.max_heap[``0``] > val):` `            ``push(``self``.max_heap, ``-``val)`   `        ``else``:` `            ``push(``self``.min_heap, val)`   `        ``# If size of max_heap + 1 greater ` `        ``# than min_heap` `        ``if` `(``len``(``self``.max_heap)``+``1` `> ` `            ``len``(``self``.min_heap)):` `            ``val ``=` `pop(``self``.max_heap)` `            ``push(``self``.min_heap, ``-``val)`   `        ``# If size of min_heap ` `        ``# greater than max_heap` `        ``if` `(``len``(``self``.min_heap) > ` `            ``len``(``self``.max_heap)):` `            ``val ``=` `pop(``self``.min_heap)` `            ``push(``self``.max_heap, ``-``val)`   `        ``# Finally if sum of sizes is odd,` `        ``# return median` `        ``if` `(``len``(``self``.min_heap) ``+` `            ``len``(``self``.max_heap)) ``%` `2` `=``=` `1``:` `            ``return` `(``-``self``.max_heap[``0``])`   `        ``# Else return 0` `        ``else``:` `            ``return` `0`   `# Function to calculate the sum ` `# of all odd length subarrays` `def` `solve(arr):` `    ``ans ``=` `0` `    `  `    ``# Size of the array` `    ``n ``=` `len``(arr)` `    ``for` `i ``in` `range``(n):` `        `  `        ``# Create an object ` `        ``# of class find_median` `        ``obj ``=` `find_median()` `        ``for` `j ``in` `range``(i, n, ``1``):` `            `  `            ``# Add value to the heaps ` `            ``# using object` `            ``val ``=` `obj.add(arr[j])` `            ``ans ``+``=` `val` `    `  `    ``return` `(ans)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``4``, ``2``, ``5``, ``1``]` `    ``print``(solve(arr))`

Output

`18`

Time Complexity: O(N2 * Log(N))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Related Articles