Sum of all Subarrays | Set 1

Given an integer array ‘arr[]’ of size n, find sum of all sub-arrays of given array.

Examples :

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

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

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

Method 1 (Simple Solution)
A simple solution is to generate all sub-array and compute their sum.

Below is the implementation of above idea.

C++

// Simple C++ program to compute sum of 
// subarray elements 
#include<bits/stdc++.h> 
using namespace std; 
  
// Computes sum all sub-array 
long int SubArraySum(int arr[], int n) 
{ 
    long int result = 0; 
  
    // Pick starting point 
    for (int i=0; i <n; i++) 
    { 
        // Pick ending point 
        for (int j=i; j<n; j++) 
        { 
            // sum subarray between current 
            // starting and ending points 
            for (int k=i; k<=j; k++) 
                result += arr[k] ; 
        } 
    } 
    return result ; 
} 
  
// driver program to test above function 
int main() 
{ 
    int arr[] = {1, 2, 3} ; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    cout << "Sum of SubArray : "
          << SubArraySum(arr, n) << endl; 
    return 0; 
} 

Java

// Simple Java program to compute sum of 
// subarray elements 
class GFG { 
      
    // Computes sum all sub-array 
    public static long SubArraySum(int arr[], int n) 
    { 
        long result = 0; 
       
        // Pick starting point 
        for (int i = 0; i < n; i ++) 
        { 
            // Pick ending point 
            for (int j = i; j < n; j ++) 
            { 
                // sum subarray between current 
                // starting and ending points 
                for (int k = i; k <= j; k++) 
                    result += arr[k] ; 
            } 
        } 
        return result ; 
    } 
      
    /* Driver program to test above function */
    public static void main(String[] args)  
    { 
        int arr[] = {1, 2, 3} ; 
        int n = arr.length; 
        System.out.println("Sum of SubArray : " +  
                          SubArraySum(arr, n)); 
    } 
} 
// This code is contributed by Arnav Kr. Mandal. 

Python 3

# Python3 program to compute  
# sum of subarray elements 
  
# Computes sum all sub-array 
def SubArraySum(arr, n): 
    result = 0
  
    # Pick starting point 
    for i in range(0, n): 
  
        # Pick ending point 
        for j in range(i, n): 
  
            # sum subarray between  
            # current starting and  
            # ending points 
            for k in range(i, j + 1): 
                result += arr[k]  
    return result  
  
# driver program  
arr = [1, 2, 3] 
n = len(arr) 
print ("Sum of SubArray :" 
       ,SubArraySum(arr, n)) 
  
# This code is contributed by  
# TheGameOf256. 

C#

// Simple C# program to compute sum of 
// subarray elements 
using System; 
  
class GFG { 
      
    // Computes sum all sub-array 
    public static long SubArraySum(int []arr, 
                                      int n) 
    { 
        long result = 0; 
      
        // Pick starting point 
        for (int i = 0; i < n; i ++) 
        { 
            // Pick ending point 
            for (int j = i; j < n; j ++) 
            { 
                  
                // sum subarray between current 
                // starting and ending points 
                for (int k = i; k <= j; k++) 
                    result += arr[k] ; 
            } 
        } 
        return result ; 
    } 
      
    // Driver Code 
    public static void Main()  
    { 
        int []arr = {1, 2, 3} ; 
        int n = arr.Length; 
        Console.Write("Sum of SubArray : " +  
                        SubArraySum(arr, n)); 
    } 
} 
  
// This code is contributed by nitin mittal 

PHP

<?php 
// Simple PHP program to  
// compute sum of subarray  
// elements Computes sum 
// all sub-array 
  
function SubArraySum($arr, $n) 
{ 
    $result = 0; 
  
    // Pick starting point 
    for ($i = 0; $i < $n; $i++) 
    { 
        // Pick ending point 
        for ($j = $i; $j < $n; $j++) 
        { 
            // sum subarray between  
            // current starting and 
            // ending points 
            for ($k = $i; $k <= $j; $k++) 
                $result += $arr[$k] ; 
        } 
    } 
    return $result ; 
} 
  
// Driver Code 
$arr = array(1, 2, 3) ; 
$n = sizeof($arr); 
echo "Sum of SubArray : ", 
    SubArraySum($arr, $n),"\n"; 
      
// This code is contributed by ajit 
?> 

Output:

Sum of SubArray : 20

Time Complexity : O(n³)

Method 2 (efficient solution)
If we take a close look then we observe a pattern. Let take an example

arr[] = [1, 2, 3], n = 3
All subarrays :  [1], [1, 2], [1, 2, 3], 
                 [2], [2, 3], [3]
here first element 'arr[0]' appears 3 times    
     second element 'arr[1]' appears 4 times  
     third element 'arr[2]' appears 3 times

Every element arr[i] appears in two types of subsets:
i)  In subarrays beginning with arr[i]. There are 
    (n-i) such subsets. For example [2] appears
    in [2] and [2, 3].
ii) In (n-i)*i subarrays where this element is not
    first element. For example [2] appears in 
    [1, 2] and [1, 2, 3].

Total of above (i) and (ii) = (n-i) + (n-i)*i 
                            = (n-i)(i+1)
                                  
For arr[] = {1, 2, 3}, sum of subarrays is:
  arr[0] * ( 0 + 1 ) * ( 3 - 0 ) + 
  arr[1] * ( 1 + 1 ) * ( 3 - 1 ) +
  arr[2] * ( 2 + 1 ) * ( 3 - 2 ) 

= 1*3 + 2*4 + 3*3 
= 20

Below is the implementation of above idea.

C++

// Efficient C++ program to compute sum of 
// subarray elements 
#include<bits/stdc++.h> 
using namespace std; 
  
//function compute sum all sub-array 
long int SubArraySum( int arr[] , int n ) 
{ 
    long int result = 0; 
  
    // computing sum of subarray using formula 
    for (int i=0; i<n; i++) 
        result += (arr[i] * (i+1) * (n-i)); 
  
    // return all subarray sum 
    return result ; 
} 
  
// driver program to test above function 
int main() 
{ 
    int arr[] = {1, 2, 3} ; 
    int n = sizeof(arr)/sizeof(arr[0]); 
    cout << "Sum of SubArray : "
         << SubArraySum(arr, n) << endl; 
    return 0; 
} 

Java

// Efficient Java program to compute sum of 
// subarray elements 
class GFG { 
      
    //function compute sum all sub-array 
    public static long SubArraySum( int arr[] , int n ) 
    { 
        long result = 0; 
       
        // computing sum of subarray using formula 
        for (int i=0; i<n; i++) 
            result += (arr[i] * (i+1) * (n-i)); 
       
        // return all subarray sum 
        return result ; 
    } 
      
    /* Driver program to test above function */
    public static void main(String[] args)  
    { 
        int arr[] = {1, 2, 3} ; 
        int n = arr.length; 
        System.out.println("Sum of SubArray " +  
                           SubArraySum(arr, n)); 
    } 
} 
// This code is contributed by Arnav Kr. Mandal. 

Python 3

#Python3 code to compute  
# sum of subarray elements 
  
#function compute sum  
# all sub-array 
def SubArraySum(arr, n ): 
    result = 0
  
    # computing sum of subarray  
    # using formula 
    for i in range(0, n): 
        result += (arr[i] * (i+1) * (n-i)) 
  
    # return all subarray sum 
    return result  
  
# driver program  
arr = [1, 2, 3] 
n = len(arr) 
print ("Sum of SubArray : ",  
      SubArraySum(arr, n)) 
  
# This code is contributed by  
# TheGameOf256. 

C#

// Efficient C# program 
// to compute sum of 
// subarray elements 
using System; 
  
class GFG 
{ 
          
    // function compute  
    // sum all sub-array 
    public static long SubArraySum(int []arr ,  
                                   int n ) 
    { 
        long result = 0; 
      
        // computing sum of  
        // subarray using formula 
        for (int i = 0; i < n; i++) 
            result += (arr[i] *  
                      (i + 1) * (n - i)); 
      
        // return all subarray sum 
        return result ; 
    } 
      
    // Driver code 
    static public void Main () 
    { 
        int []arr = {1, 2, 3} ; 
        int n = arr.Length; 
        Console.WriteLine("Sum of SubArray: " +  
                          SubArraySum(arr, n)); 
    } 
} 
  
// This code is contributed by akt_mit 

PHP

<?php 
// Efficient PHP program to compute  
// sum of subarray elements 
  
//function compute sum all sub-array 
function SubArraySum($arr , $n) 
{ 
    $result = 0; 
  
    // computing sum of subarray 
    // using formula 
    for ($i = 0; $i < $n; $i++) 
        $result += ($arr[$i] *  
                    ($i + 1) *  
                    ($n - $i)); 
  
    // return all subarray sum 
    return $result ; 
} 
  
// Driver Code 
$arr = array(1, 2, 3) ; 
$n = sizeof($arr); 
echo "Sum of SubArray : ", 
      SubArraySum($arr, $n) ,"\n"; 
  
  
#This code is contributed by aj_36 
?> 

Output :

Sum of SubArray : 20

Time complexity : O(n)

Reference :
https://www.quora.com/Can-we-find-the-sum-of-all-sub-arrays-of-an-integer-array-in-O-n-time

Sum of all subsequences of an array

This article is contributed by Nishant Singh. 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 write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes

Suggest a Topic

Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

C++

Java

Python 3

C#

PHP

C++

Java

Python 3

C#

PHP

Recommended Posts: