# 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++ 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 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`

 `# 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# 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`

Output
`6 2 1 `

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :