Skip to content
Related Articles

Related Articles

Improve Article

Sum of product of all elements of sub-arrays of size k

  • Difficulty Level : Easy
  • Last Updated : 05 Jul, 2021

Given an array and a number k, the task is to calculate the sum of the product of all elements of subarrays of size k.
Examples : 
 

Input : arr[] = {1, 2, 3, 4, 5, 6} 
                k = 3
Output : 210
Consider all subarrays of size k
1*2*3 = 6
2*3*4 = 24
3*4*5 = 60
4*5*6 = 120
6 + 24 + 60 + 120 = 210

Input : arr[] = {1, -2, 3, -4, 5, 6} 
            k = 2
Output : -10
Consider all subarrays of size k
1*-2 = -2
-2*3 = -6
3*-4 = -12
-4*5 = -20
5*6  =   30
-2 + -6 + -12 + -20+ 30 = -10

 

A Naive approach is to generate all subarrays of size k and do the sum of product of all elements of subarrays. 
 
 

C++




// C++ program to find the sum of
// product of all subarrays
#include <iostream>
using namespace std;
 
// Function to calculate the sum of product
int calcSOP(int arr[], int n, int k)
{
    // Initialize sum = 0
    int sum = 0;
 
    // Consider every subarray of size k
    for (int i = 0; i <= n - k; i++) {
        int prod = 1;
 
        // Calculate product of all elements
        // of current subarray
        for (int j = i; j < k + i; j++)
            prod *= arr[j];
 
        // Store sum of all the products
        sum += prod;
    }
 
    // Return sum
    return sum;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 2, 3, 4, 5, 6 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 3;
 
    cout << calcSOP(arr, n, k);
 
    return 0;
}
Java



// Java program to find the sum of
// product of all subarrays
 
class GFG {
    // Method to calculate the sum of product
    static int calcSOP(int arr[], int n, int k)
    {
        // Initialize sum = 0
        int sum = 0;
 
        // Consider every subarray of size k
        for (int i = 0; i <= n - k; i++) {
            int prod = 1;
 
            // Calculate product of all elements
            // of current subarray
            for (int j = i; j < k + i; j++)
                prod *= arr[j];
 
            // Store sum of all the products
            sum += prod;
        }
 
        // Return sum
        return sum;
    }
 
    // Driver method
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 3, 4, 5, 6 };
        int k = 3;
 
        System.out.println(calcSOP(arr, arr.length, k));
    }
}
Python3



# python program to find the sum of
# product of all subarrays
 
# Function to calculate the sum of product
def calcSOP(arr, n, k):
     
    # Initialize sum = 0
    sum = 0
 
    # Consider every subarray of size k
    for i in range(0, (n-k)+1):
        prod = 1
         
        # Calculate product of all elements
        # of current subarray
        for j in range(i, k+i):
            prod = int(prod * arr[j])
 
        # Store sum of all the products
        sum = sum + prod
     
    # Return sum
    return sum
 
#Driver code
arr = [ 1, 2, 3, 4, 5, 6 ]
n = len(arr)
k = 3
print(calcSOP(arr, n, k))
 
# This code is contributed by Sam007
C#



// C# program to find the sum of
// product of all subarrays
using System;
 
public class GFG {
     
    // Method to calculate the sum of product
    static int calcSOP(int[] arr, int n, int k)
    {
        // Initialize sum = 0
        int sum = 0;
 
        // Consider every subarray of size k
        for (int i = 0; i <= n - k; i++) {
            int prod = 1;
 
            // Calculate product of all elements
            // of current subarray
            for (int j = i; j < k + i; j++)
                prod *= arr[j];
 
            // Store sum of all the products
            sum += prod;
        }
 
        // Return sum
        return sum;
    }
 
    // Driver method
    public static void Main()
    {
        int[] arr = {1, 2, 3, 4, 5, 6};
        int k = 3;
 
        Console.WriteLine(calcSOP(arr, arr.Length, k));
    }
}
 
// This code is contributed by Sam007
PHP 

<?php
// PHP program to find the sum of
// product of all subarrays

// Function to calculate
// the sum of product
function calcSOP($arr, $n, $k)
{
    
    // Initialize sum = 0
    $sum = 0;

    // Consider every subarray 
    // of size k
    for ($i = 0; $i <= $n - $k; $i++)
    {
        $prod = 1;

        // Calculate product of all 
        // elements of current subarray
        for ($j = $i; $j < $k + $i; $j++)
            $prod *= $arr[$j];

        // Store sum of all 
        // the products
        $sum += $prod;
    }

    // Return sum
    return $sum;
}

    // Driver code
    $arr = array( 1, 2, 3, 4, 5, 6 );
    $n = count($arr);
    $k = 3;

    echo calcSOP($arr, $n, $k);
        
// This code is contributed by Sam007
?>




Javascript





<script>
// Javascript program to find the sum of
// product of all subarrays
 
// Function to calculate
// the sum of product
function calcSOP(arr, n, k) {
 
    // Initialize sum = 0
    let sum = 0;
 
    // Consider every subarray
    // of size k
    for (let i = 0; i <= n - k; i++) {
        let prod = 1;
 
        // Calculate product of all
        // elements of current subarray
        for (let j = i; j < k + i; j++)
            prod *= arr[j];
 
        // Store sum of all
        // the products
        sum += prod;
    }
 
    // Return sum
    return sum;
}
 
// Driver code
let arr = new Array(1, 2, 3, 4, 5, 6);
let n = arr.length;
let k = 3;
 
document.write(calcSOP(arr, n, k));
 
// This code is contributed by gfgking
</script>
Output: 
 
210
Time Complexity: O(nk)
An Efficient Method is to use the concept of Sliding Window.
1- Consider first subarray/window of size k, do the product of elements and add to the total_sum. 
 
 for (i=0; i < k; i++)
       prod = prod * arr[i];
2- Now, By Using sliding window concept, remove first element of window from the product and add next element to the window. i.e. 
 
for (i =k ; i < n; i++)
 {
     // Removing first element from product  
     prod = prod / arr[i-k]; 

     //  Adding current element to the product
     prod = prod * arr[i];  
     sum += prod;
 }
3- Return sum
 
C/C++
 
 
Java



// Java program to find the sum of
// product of all subarrays
 
class GFG {
    // Method to calculate the sum of product
    static int calcSOP(int arr[], int n, int k)
    {
        // Initialize sum = 0 and prod = 1
        int sum = 0, prod = 1;
 
        // Consider first subarray of size k
        // Store the products of elements
        for (int i = 0; i < k; i++)
            prod *= arr[i];
 
        // Add the product to the sum
        sum += prod;
 
        // Consider every subarray of size k
        // Remove first element and add current
        // element to the window
        for (int i = k; i < n; i++) {
 
            // Divide by the first element
            // of previous subarray/ window
            // and product with the current element
            prod = (prod / arr[i - k]) * arr[i];
 
            // Add current product to the sum
            sum += prod;
        }
 
        // Return sum
        return sum;
    }
 
    // Driver method
    public static void main(String[] args)
    {
        int arr[] = { 1, 2, 3, 4, 5, 6 };
        int k = 3;
 
        System.out.println(calcSOP(arr, arr.length, k));
    }
}
Python3



# Python3 program to find the sum of
# product of all subarrays
 
# Function to calculate the sum of product
def calcSOP(arr, n, k):
     
    # Initialize sum = 0 and prod = 1
    sum = 0
    prod = 1
 
    # Consider first subarray of size k
    # Store the products of elements
    for i in range(k):
        prod *= arr[i]
 
    # Add the product to the sum
    sum += prod
 
    # Consider every subarray of size k
    # Remove first element and add current
    # element to the window
    for i in range(k, n, 1):
         
        # Divide by the first element of
        #  previous subarray/ window and
        # product with the current element
        prod = (prod / arr[i - k]) * arr[i]
 
        # Add current product to the sum
        sum += prod
 
    # Return sum
    return int(sum)
 
# Drivers code
arr = [1, 2, 3, 4, 5, 6]
n = len(arr)
k = 3
 
print(calcSOP(arr, n, k))
 
# This code is contributed 29AjayKumar
C#



// C# program to find the sum of
// product of all subarrays
using System;
 
public class GFG {
     
    // Method to calculate the sum of product
    static int calcSOP(int[] arr, int n, int k)
    {
        // Initialize sum = 0 and prod = 1
        int sum = 0, prod = 1;
 
        // Consider first subarray of size k
        // Store the products of elements
        for (int i = 0; i < k; i++)
            prod *= arr[i];
 
        // Add the product to the sum
        sum += prod;
 
        // Consider every subarray of size k
        // Remove first element and add current
        // element to the window
        for (int i = k; i < n; i++) {
 
            // Divide by the first element
            // of previous subarray/ window
            // and product with the current element
            prod = (prod / arr[i - k]) * arr[i];
 
            // Add current product to the sum
            sum += prod;
        }
 
        // Return sum
        return sum;
    }
 
    // Driver method
    public static void Main()
    {
        int[] arr = { 1, 2, 3, 4, 5, 6 };
        int k = 3;
         
        // Function calling
        Console.WriteLine(calcSOP(arr, arr.Length, k));
    }
}
 
// This code is contributed by Sam007
PHP



<?php
 
// php program to find the sum of
// product of all subarrays
 
// Function to calculate the sum of product
function calcSOP($arr, $n, $k)
{
    // Initialize sum = 0 and prod = 1
    $sum = 0;
    $prod = 1;
  
    // Consider first subarray of size k
    // Store the products of elements
    for ($i = 0; $i < $k; $i++)
        $prod *= $arr[$i];
  
    // Add the product to the sum
    $sum += $prod;
  
    // Consider every subarray of size k
    // Remove first element and add current
    // element to the window
    for ($i = $k; $i < $n; $i++) {
  
        // Divide by the first element
        // of previous subarray/ window
        // and product with the current element
        $prod = ($prod / $arr[$i - $k]) * $arr[$i];
  
        // Add current product to the sum
        $sum += $prod;
    }
  
    // Return sum
    return $sum;
}
  
// Drivers code
    $arr = array( 1, 2, 3, 4, 5, 6 );
    $n = count($arr);
    $k = 3;
  
    echo calcSOP($arr, $n, $k);
  
// This code is contributed by Sam007
?>
Javascript



<script>
        // JavaScript program for the above approach
 
function calcSOP(arr,n,k)
    {
        // Initialize sum = 0 and prod = 1
        let sum = 0, prod = 1;
 
        // Consider first subarray of size k
        // Store the products of elements
        for (let i = 0; i < k; i++)
            prod *= arr[i];
 
        // Add the product to the sum
        sum += prod;
 
        // Consider every subarray of size k
        // Remove first element and add current
        // element to the window
        for (let i = k; i < n; i++) {
 
            // Divide by the first element
            // of previous subarray/ window
            // and product with the current element
            prod = (Math.floor(prod / arr[i - k])) * arr[i];
 
            // Add current product to the sum
            sum += prod;
        }
 
        // Return sum
        return sum;
    }
 
    // Driver method
    
        let arr= [1, 2, 3, 4, 5, 6 ];
        let k = 3;
 
        document.write(calcSOP(arr, arr.length, k));
    
 
    // This code is contributed by Potta Lokesh
 
    </script>
Output: 
 
210
Time Complexity: O(n)
This article is contributed by Sahil Chhabra. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Next

Sum of the products of all possible Subsets
Recommended Articles
Page :
Maximum subarray size, such that all subarrays of that size have sum less than k
30, Dec 16
Sum of minimum and maximum elements of all subarrays of size k.
04, Jan 17
Split array into K subarrays such that sum of maximum of all subarrays is maximized
11, Jun 21
Maximum product from array such that frequency sum of all repeating elements in product is less than or equal to 2 * k
18, Feb 19
Sum of all subarrays of size K
26, Mar 20
Generate Array whose sum of all K-size subarrays divided by N leaves remainder X
29, Jun 20
Maximize sum of product of same-indexed elements of equal length subarrays obtained from two given arrays
30, Apr 21
Product of all Subsequences of size K except the minimum and maximum Elements
18, Apr 19
Product of all sorted subsets of size K using elements whose index divide K completely
08, May 20
Maximize product of array by replacing array elements with its sum or product with element from another array
27, Oct 20
Count of subarrays of size K with elements having even frequencies
14, Jun 20
Counting inversions in all subarrays of given size
17, Oct 17
Min difference between maximum and minimum element in all Y size subarrays
13, Jul 20
Maximum of all Subarrays of size k using set in C++ STL
11, Jan 19
Minimum and Maximum of all subarrays of size K using Map
04, May 20
Sliding Window Maximum (Maximum of all subarrays of size k) using stack in O(n) time
25, Apr 19
Maximum of all subarrays of size K using Segment Tree
13, May 20
Minimum cost required to convert all Subarrays of size K to a single element
07, Aug 20
Ratio of all subarrays of size K
17, Sep 20
GCD of all subarrays of size K
24, Sep 20
Minimum common element in all subarrays of size K
04, Oct 20
Sliding Window Maximum (Maximum of all subarrays of size k)
27, May 11
Product of all Subarrays of an Array
07, Apr 20
Product of all non repeating Subarrays of an Array
06, May 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox