Sum of all subarrays of size K
Given an array arr[] and an integer K, the task is to calculate the sum of all subarrays of size K.
Examples:
Input: arr[] = {1, 2, 3, 4, 5, 6}, K = 3
Output: 6 9 12 15
Explanation:
All subarrays of size k and their sum:
Subarray 1: {1, 2, 3} = 1 + 2 + 3 = 6
Subarray 2: {2, 3, 4} = 2 + 3 + 4 = 9
Subarray 3: {3, 4, 5} = 3 + 4 + 5 = 12
Subarray 4: {4, 5, 6} = 4 + 5 + 6 = 15
Input: arr[] = {1, -2, 3, -4, 5, 6}, K = 2
Output: -1, 1, -1, 1, 11
Explanation:
All subarrays of size K and their sum:
Subarray 1: {1, -2} = 1 – 2 = -1
Subarray 2: {-2, 3} = -2 + 3 = -1
Subarray 3: {3, 4} = 3 – 4 = -1
Subarray 4: {-4, 5} = -4 + 5 = 1
Subarray 5: {5, 6} = 5 + 6 = 11
Naive Approach: The naive approach will be to generate all subarrays of size K and find the sum of each subarray using iteration.
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
int calcSum( int arr[], int n, int k)
{
for ( int i = 0; i <= n - k; i++) {
int sum = 0;
for ( int j = i; j < k + i; j++)
sum += arr[j];
cout << sum << " " ;
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 3;
calcSum(arr, n, k);
return 0;
}
|
Java
class GFG{
static void calcSum( int arr[], int n, int k)
{
for ( int i = 0 ; i <= n - k; i++) {
int sum = 0 ;
for ( int j = i; j < k + i; j++)
sum += arr[j];
System.out.print(sum+ " " );
}
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 , 6 };
int n = arr.length;
int k = 3 ;
calcSum(arr, n, k);
}
}
|
C#
using System;
class GFG
{
static void calcSum( int [] arr, int n, int k)
{
for ( int i = 0; i <= n - k; i++) {
int sum = 0;
for ( int j = i; j < k + i; j++)
sum += arr[j];
Console.Write(sum + " " );
}
}
static void Main()
{
int [] arr = new int [] { 1, 2, 3, 4, 5, 6 };
int n = arr.Length;
int k = 3;
calcSum(arr, n, k);
}
}
|
Python3
def calcSum(arr, n, k):
for i in range (n - k + 1 ):
sum = 0
for j in range (i, k + i):
sum + = arr[j]
print ( sum , end = " " )
arr = [ 1 , 2 , 3 , 4 , 5 , 6 ]
n = len (arr)
k = 3
calcSum(arr, n, k)
|
Javascript
<script>
function calcSum(arr, n, k)
{
for ( var i = 0; i <= n - k; i++) {
var sum = 0;
for ( var j = i; j < k + i; j++)
sum += arr[j];
document.write(sum + " " );
}
}
var arr = [ 1, 2, 3, 4, 5, 6 ];
var n = arr.length;
var k = 3;
calcSum(arr, n, k);
</script>
|
Performance Analysis:
- Time Complexity: As in the above approach, There are two loops, where first loop runs (N – K) times and second loop runs for K times. Hence the Time Complexity will be O(N*K).
- Auxiliary Space Complexity: As in the above approach. There is no extra space used. Hence the auxiliary space complexity will be O(1).
Efficient Approach: Using Sliding Window The idea is to use the sliding window approach to find the sum of all possible subarrays in the array.
- For each size in the range [0, K], find the sum of the first window of size K and store it in an array.
- Then for each size in the range [K, N], add the next element which contributes into the sliding window and subtract the element which pops out from the window.
// Adding the element which
// adds into the new window
sum = sum + arr[j]
// Subtracting the element which
// pops out from the window
sum = sum - arr[j-k]
where sum is the variable to store the result
arr is the given array
j is the loop variable in range [K, N]
Below is the implementation of the above approach:
C++
#include <iostream>
using namespace std;
int calcSum( int arr[], int n, int k)
{
int sum = 0;
for ( int i = 0; i < k; i++)
sum += arr[i];
cout << sum << " " ;
for ( int i = k; i < n; i++) {
sum = (sum - arr[i - k]) + arr[i];
cout << sum << " " ;
}
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 3;
calcSum(arr, n, k);
return 0;
}
|
Java
class GFG{
static void calcSum( int arr[], int n, int k)
{
int sum = 0 ;
for ( int i = 0 ; i < k; i++)
sum += arr[i];
System.out.print(sum+ " " );
for ( int i = k; i < n; i++) {
sum = (sum - arr[i - k]) + arr[i];
System.out.print(sum+ " " );
}
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 , 6 };
int n = arr.length;
int k = 3 ;
calcSum(arr, n, k);
}
}
|
Python3
def calcSum(arr, n, k):
sum = 0
for i in range ( k):
sum + = arr[i]
print ( sum ,end = " " )
for i in range (k,n):
sum = ( sum - arr[i - k]) + arr[i]
print ( sum ,end = " " )
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 , 6 ]
n = len (arr)
k = 3
calcSum(arr, n, k)
|
C#
using System;
class GFG{
static void calcSum( int []arr, int n, int k)
{
int sum = 0;
for ( int i = 0; i < k; i++)
sum += arr[i];
Console.Write(sum+ " " );
for ( int i = k; i < n; i++) {
sum = (sum - arr[i - k]) + arr[i];
Console.Write(sum + " " );
}
}
public static void Main(String[] args)
{
int []arr = { 1, 2, 3, 4, 5, 6 };
int n = arr.Length;
int k = 3;
calcSum(arr, n, k);
}
}
|
Javascript
<script>
function calcSum(arr, n, k)
{
var sum = 0;
for ( var i = 0; i < k; i++)
sum += arr[i];
document.write( sum + " " );
for ( var i = k; i < n; i++) {
sum = (sum - arr[i - k]) + arr[i];
document.write( sum + " " );
}
}
var arr = [ 1, 2, 3, 4, 5, 6 ];
var n = arr.length;
var k = 3;
calcSum(arr, n, k);
</script>
|
Performance Analysis:
- Time Complexity: As in the above approach. There is one loop which take O(N) time. Hence the Time Complexity will be O(N).
- Auxiliary Space Complexity: As in the above approach. There is no extra space used. Hence the auxiliary space complexity will be O(1).
Related Topic: Subarrays, Subsequences, and Subsets in Array
Last Updated :
11 Jul, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...