GeeksforGeeks App
Open App
Browser
Continue

# First subarray having sum at least half the maximum sum of any subarray of size K

Given an array arr[] and an integer K, the task is to find the first subarray which has a sum greater than or equal to half of the maximum possible sum from any subarray of size K.

Examples:

Input: arr[] = {2, 4, 5, 1, 4, 6, 6, 2, 1, 0}, K = 3
Output: 6 2 1
Explanation:
The given array has a maximum possible sum from any subarray of size K is 16 from the subarray {4, 6, 6}
So, the required subarray sum should be greater than or equal to 8
{6, 2, 1} is the first subarray which has a sum of 9 which is greater than 8.

Input: arr[] = {12, 45, 11, 10, 8, 56, 2}, K = 4
Output: 45 11 10

Approach: This problem can be solved using the sliding windows technique because subarrays are to be taken into consideration. Follow the steps below to solve this problem:

1. Calculate the sum of all subarrays of size K and store them in an array.
2. Now, find the maximum of all the sums.
3. Iterate over the array and find a sum that is greater than or equal to half of the maximum subarray sum obtained above.
4. Print the subarray satisfying the above condition.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the above approach``#include ``#include ``using` `namespace` `std;` `// Function to print the subarray with sum``// greater or equal than the half of``// the maximum subarray sum of K size``void` `subArray(``int` `arr[], ``int` `n, ``int` `k)``{``    ``int` `sum = 0;` `    ``// Storing sum of first subarray``    ``for` `(``int` `i = 0; i < k; i++) {``        ``sum += arr[i];``    ``}` `    ``// Vector to store the``    ``// subarray sums``    ``vector<``int``> res;``    ``res.push_back(sum);` `    ``// Sliding window technique to``    ``// Find sum of subarrays of size K``    ``for` `(``int` `i = k; i < n; i++) {``        ``sum -= arr[i - k];``        ``sum += arr[i];``        ``res.push_back(sum);``    ``}` `    ``// Maximum sub-array sum``    ``int` `max_sum = *max_element(res.begin(),``                               ``res.end());` `    ``int` `half = max_sum / 2;` `    ``// Create a copy vector``    ``vector<``int``> copy = res;` `    ``// Sort the vector``    ``sort(copy.begin(),copy.end()); ``  ` `    ``int` `half_index, half_sum;` `    ``// Check in a sorted array for``    ``// an element exceeding``    ``// half of the max_sum``    ``for` `(``auto` `x : copy) {``        ``if` `(x >= half) {``            ``half_sum = x;``            ``break``;``        ``}``    ``}` `    ``// Calculate index of first``    ``// subarray having required sum``    ``for` `(``int` `x = 0; x < res.size(); x++) {``        ``if` `(res[x] == half_sum) {``            ``half_index = x;``            ``break``;``        ``}``    ``}` `    ``// Print the subarray``    ``for` `(``int` `i = 1; i <= k; i++) {``        ``cout << arr[half_index + i - 1]``             ``<< ``" "``;``    ``}``}` `// Driver Code``int` `main()``{``    ``// Given array``    ``int` `arr[] = { 2, 4, 5, 1, 4, 6, 6, 2, 1, 0 };``    ``int` `k = 3;``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function Call``    ``subArray(arr, n, k);` `    ``return` `0;``}``// This code is contributed by akshitdiwan05`

## Java

 `// Java implementation of``// the above approach``import` `java.util.*;``class` `GFG{` `// Function to print the subarray with sum``// greater or equal than the half of``// the maximum subarray sum of K size``static` `void` `subArray(``int` `arr[],``                     ``int` `n, ``int` `k)``{``  ``int` `sum = ``0``;` `  ``// Storing sum of first subarray``  ``for` `(``int` `i = ``0``; i < k; i++)``  ``{``    ``sum += arr[i];``  ``}` `  ``// Vector to store the``  ``// subarray sums``  ``Vector res = ``new` `Vector<>();``  ``res.add(sum);` `  ``// Sliding window technique to``  ``// Find sum of subarrays of size K``  ``for` `(``int` `i = k; i < n; i++)``  ``{``    ``sum -= arr[i - k];``    ``sum += arr[i];``    ``res.add(sum);``  ``}` `  ``// Maximum sub-array sum``  ``int` `max_sum = res.elementAt(``0``);``  ``for``(``int` `i =``0``; i < res.size(); i++)``  ``{``    ``if``(max_sum < res.elementAt(i))``    ``{``      ``max_sum = res.elementAt(i);``    ``}``  ``}` `  ``int` `half = max_sum / ``2``;` `  ``// Create a copy vector``  ``Vector copy =``                  ``new` `Vector<>(res);` `  ``// Sort the vector``  ``Collections.sort(copy);``  ``int` `half_index = ``0``, half_sum = ``0``;` `  ``// Check in a sorted array for``  ``// an element exceeding``  ``// half of the max_sum``  ``for` `(``int` `x = ``0``; x < copy.size(); x++)``  ``{``    ``if` `(copy.elementAt(x) >= half)``    ``{``      ``half_sum = copy.elementAt(x);``      ``break``;``    ``}``  ``}` `  ``// Calculate index of first``  ``// subarray having required sum``  ``for` `(``int` `x = ``0``; x < res.size(); x++)``  ``{``    ``if` `(res.elementAt(x) == half_sum)``    ``{``      ``half_index = x;``      ``break``;``    ``}``  ``}` `  ``// Print the subarray``  ``for` `(``int` `i = ``1``; i <= k; i++)``  ``{``    ``System.out.print(``           ``arr[half_index + i - ``1``] + ``" "``);``  ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``// Given array``  ``int` `arr[] = {``2``, ``4``, ``5``, ``1``, ``4``,``               ``6``, ``6``, ``2``, ``1``, ``0``};``  ``int` `k = ``3``;``  ``int` `n = arr.length;` `  ``// Function Call``  ``subArray(arr, n, k);``}``}` `// This code is contributed by gauravrajput1`

## Python3

 `# Python 3 implementation``# of the above approach` `# Function to print the``# subarray with sum greater``# or equal than the half of``# the maximum subarray``# sum of K size``def` `subArray(arr, n, k):` `    ``sum` `=` `0` `    ``# Storing sum of``    ``# first subarray``    ``for` `i ``in` `range` `(k):``        ``sum` `+``=` `arr[i]``   ` `    ``# Vector to store the``    ``# subarray sums``    ``res ``=` `[]``    ``res.append(``sum``)` `    ``# Sliding window technique``    ``# to find sum of subarrays``    ``# of size K``    ``for` `i ``in` `range` `(k, n):``        ``sum` `-``=` `arr[i ``-` `k]``        ``sum` `+``=` `arr[i]``        ``res.append(``sum``)``   ` `    ``# Maximum sub-array sum``    ``max_sum ``=` `max``(res)``    ``half ``=` `max_sum ``/``/` `2` `    ``# Create a copy vector``    ``copy ``=` `res.copy()` `    ``# Sort the vector``    ``copy.sort()`` ` `    ``# Check in a sorted array for``    ``# an element exceeding``    ``# half of the max_sum``    ``for` `x ``in` `copy:``        ``if` `(x >``=` `half):``            ``half_sum ``=` `x``            ``break``      ` `    ``# Calculate index of first``    ``# subarray having required sum``    ``for` `x ``in` `range` `(``len``(res)):``        ``if` `(res[x] ``=``=` `half_sum):``            ``half_index ``=` `x``            ``break``    ` `    ``# Print the subarray``    ``for` `i ``in` `range` `(``1``, k ``+` `1``):``        ``print` `(arr[half_index ``+` `i ``-` `1``] ,``               ``end ``=` `" "``)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``  ` `    ``# Given array``    ``arr ``=` `[``2``, ``4``, ``5``, ``1``, ``4``,``           ``6``, ``6``, ``2``, ``1``, ``0``]``    ``k ``=` `3``    ``n ``=` `len``(arr)` `    ``# Function Call``    ``subArray(arr, n, k);` `# This code is contributed by Chitranayal`

## C#

 `// C# implementation of``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to print the subarray with sum``// greater or equal than the half of``// the maximum subarray sum of K size``static` `void` `subArray(``int` `[]arr,``                     ``int` `n, ``int` `k)``{``    ``int` `sum = 0;``    ` `    ``// Storing sum of first subarray``    ``for``(``int` `i = 0; i < k; i++)``    ``{``        ``sum += arr[i];``    ``}``    ` `    ``// List to store the``    ``// subarray sums``    ``List<``int``> res = ``new` `List<``int``>();``    ``res.Add(sum);``    ` `    ``// Sliding window technique to``    ``// Find sum of subarrays of size K``    ``for``(``int` `i = k; i < n; i++)``    ``{``        ``sum -= arr[i - k];``        ``sum += arr[i];``        ``res.Add(sum);``    ``}``    ` `    ``// Maximum sub-array sum``    ``int` `max_sum = res[0];``    ``for``(``int` `i = 0; i < res.Count; i++)``    ``{``        ``if` `(max_sum < res[i])``        ``{``            ``max_sum = res[i];``        ``}``    ``}``    ` `    ``int` `half = max_sum / 2;``    ` `    ``// Create a copy vector``    ``List<``int``> copy = ``new` `List<``int``>(res);``    ` `    ``// Sort the vector``    ``copy.Sort();``    ``int` `half_index = 0, half_sum = 0;``    ` `    ``// Check in a sorted array for``    ``// an element exceeding``    ``// half of the max_sum``    ``for``(``int` `x = 0; x < copy.Count; x++)``    ``{``        ``if` `(copy[x] >= half)``        ``{``            ``half_sum = copy[x];``            ``break``;``        ``}``    ``}``    ` `    ``// Calculate index of first``    ``// subarray having required sum``    ``for``(``int` `x = 0; x < res.Count; x++)``    ``{``        ``if` `(res[x] == half_sum)``        ``{``            ``half_index = x;``            ``break``;``        ``}``    ``}``    ` `    ``// Print the subarray``    ``for``(``int` `i = 1; i <= k; i++)``    ``{``        ``Console.Write(``            ``arr[half_index + i - 1] + ``" "``);``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given array``    ``int` `[]arr = { 2, 4, 5, 1, 4,``                  ``6, 6, 2, 1, 0 };``    ``int` `k = 3;``    ``int` `n = arr.Length;``    ` `    ``// Function call``    ``subArray(arr, n, k);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output

`6 2 1 `

Time complexity: O(NlogN)
Space Complexity: O(N)

My Personal Notes arrow_drop_up