Given an integer array ‘arr[]’ of size N, find the sum of all sub-arrays of the 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
Naive Approach: To solve the problem follow the below idea:
A simple solution is to generate all sub-arrays and compute their sum
Follow the below steps to solve the problem:
- Generate all subarrays using nested loops
- Take the sum of all these subarrays
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
long int SubArraySum(int arr[], int n)
{
long int result = 0, temp = 0;
for (int i = 0; i < n; i++) {
temp = 0;
for (int j = i; j < n; j++) {
temp += arr[j];
result += temp;
}
}
return result;
}
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
class GFG {
public static long SubArraySum(int arr[], int n)
{
long result = 0, temp = 0;
for (int i = 0; i < n; i++) {
temp = 0;
for (int j = i; j < n; j++) {
temp += arr[j];
result += temp;
}
}
return result;
}
public static void main(String[] args)
{
int arr[] = { 1, 2, 3 };
int n = arr.length;
System.out.println("Sum of SubArray : "
+ SubArraySum(arr, n));
}
}
|
Python3
def SubArraySum(arr, n):
temp, result = 0, 0
for i in range(0, n):
temp = 0
for j in range(i, n):
temp += arr[j]
result += temp
return result
arr = [1, 2, 3]
n = len(arr)
print("Sum of SubArray :", SubArraySum(arr, n))
|
C#
using System;
class GFG {
public static long SubArraySum(int[] arr, int n)
{
long result = 0, temp = 0;
for (int i = 0; i < n; i++) {
temp = 0;
for (int j = i; j < n; j++) {
temp += arr[j];
result += temp;
}
}
return result;
}
public static void Main()
{
int[] arr = { 1, 2, 3 };
int n = arr.Length;
Console.Write("Sum of SubArray : "
+ SubArraySum(arr, n));
}
}
|
PHP
<?php
function SubArraySum($arr, $n)
{
$result = 0;
$temp = 0;
for ($i = 0; $i < $n; $i++)
{
$temp=0;
for ($j = $i; $j < $n; $j++)
{
$temp+=$arr[$j];
$result += $temp ;
}
}
return $result ;
}
$arr = array(1, 2, 3) ;
$n = sizeof($arr);
echo "Sum of SubArray : ",
SubArraySum($arr, $n),"\n";
?>
|
Javascript
<script>
function SubArraySum(arr, n)
{
let result = 0,temp=0;
for (let i=0; i <n; i++)
{
temp=0;
for (let j=i; j<n; j++)
{
temp+=arr[j];
result += temp ;
}
}
return result ;
}
let arr = [1, 2, 3] ;
let n = arr.length;
document.write("Sum of SubArray : "
+ SubArraySum(arr, n) + "<br>");
</script>
|
OutputSum of SubArray : 20
Time Complexity: O(N2)
Auxiliary Space: O(1)
Sum of all Subarrays using prefix-sum:
To solve the problem follow the below idea:
We can construct a prefix-sum array and extract the subarray sum between starting and ending indices of every subarray.
Follow the below steps to solve the problem:
- Create a prefix sum array for the input array
- Generate the starting and ending indices for all the possible subarrays
- Extract their sum from the prefix sum array and add it in the answer
- Return answer
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
void buildPrefixSumArray(int arr[], int n,
int prefixSumArray[])
{
prefixSumArray[0] = arr[0];
for (int i = 1; i < n; i++)
prefixSumArray[i] = prefixSumArray[i - 1] + arr[i];
}
ll SubArraySum(int arr[], int n)
{
ll result = 0, sum = 0;
int prefixSumArr[n] = { 0 };
buildPrefixSumArray(arr, n, prefixSumArr);
for (int i = 0; i < n; i++) {
sum = 0;
for (int j = i; j < n; j++) {
if (i != 0) {
sum = prefixSumArr[j] - prefixSumArr[i - 1];
}
else
sum = prefixSumArr[j];
result += sum;
}
}
return result;
}
int main()
{
int arr[] = { 1, 2, 3, 4 };
int n = sizeof(arr) / sizeof(arr[0]);
ll ans = SubArraySum(arr, n);
cout << "Sum of SubArray : " << ans << endl;
return 0;
}
|
Java
class GFG {
public static void
buildPrefixSumArray(int arr[], int n,
int prefixSumArray[])
{
prefixSumArray[0] = arr[0];
for (int i = 1; i < n; i++)
prefixSumArray[i]
= prefixSumArray[i - 1] + arr[i];
}
public static long SubArraySum(int arr[], int n)
{
long result = 0, sum = 0;
int[] prefixSumArr = new int[n];
buildPrefixSumArray(arr, n, prefixSumArr);
for (int i = 0; i < n; i++) {
sum = 0;
for (int j = i; j < n; j++) {
if (i != 0) {
sum = prefixSumArr[j]
- prefixSumArr[i - 1];
}
else
sum = prefixSumArr[j];
result += sum;
}
}
return result;
}
public static void main(String[] args)
{
int arr[] = { 1, 2, 3, 4 };
int n = arr.length;
System.out.println("Sum of SubArray : "
+ SubArraySum(arr, n));
}
}
|
Python3
class GFG:
@staticmethod
def buildPrefixSumArray(arr, n, prefixSumArray):
prefixSumArray[0] = arr[0]
i = 1
while (i < n):
prefixSumArray[i] = prefixSumArray[i - 1] + arr[i]
i += 1
@staticmethod
def SubArraySum(arr, n):
result = 0
sum = 0
prefixSumArr = [0] * (n)
GFG.buildPrefixSumArray(arr, n, prefixSumArr)
i = 0
while (i < n):
sum = 0
j = i
while (j < n):
if (i != 0):
sum = prefixSumArr[j] - prefixSumArr[i - 1]
else:
sum = prefixSumArr[j]
result += sum
j += 1
i += 1
return result
@staticmethod
def main(args):
arr = [1, 2, 3, 4]
n = len(arr)
print("Sum of SubArray : " + str(GFG.SubArraySum(arr, n)))
if __name__ == "__main__":
GFG.main([])
|
C#
using System;
public class GFG {
public static void
buildPrefixSumArray(int[] arr, int n,
int[] prefixSumArray)
{
prefixSumArray[0] = arr[0];
for (int i = 1; i < n; i++) {
prefixSumArray[i]
= prefixSumArray[i - 1] + arr[i];
}
}
public static long SubArraySum(int[] arr, int n)
{
var result = 0;
var sum = 0;
int[] prefixSumArr = new int[n];
GFG.buildPrefixSumArray(arr, n, prefixSumArr);
for (int i = 0; i < n; i++) {
sum = 0;
for (int j = i; j < n; j++) {
if (i != 0) {
sum = prefixSumArr[j]
- prefixSumArr[i - 1];
}
else {
sum = prefixSumArr[j];
}
result += sum;
}
}
return result;
}
public static void Main(String[] args)
{
int[] arr = { 1, 2, 3, 4 };
var n = arr.Length;
Console.WriteLine(
"Sum of SubArray : "
+ GFG.SubArraySum(arr, n).ToString());
}
}
|
Javascript
function buildPrefixSumArray(arr, n, prefixSumArray)
{
prefixSumArray[0] = arr[0];
for (let i = 1; i < n; i++)
prefixSumArray[i] = prefixSumArray[i - 1] + arr[i];
}
function SubArraySum(arr, n)
{
let result = 0, sum = 0;
let prefixSumArr = [];
for (let i = 0; i < n; i++) {
prefixSumArr.push(0);
}
buildPrefixSumArray(arr, n, prefixSumArr);
for (let i = 0; i < n; i++) {
sum = 0;
for (let j = i; j < n; j++) {
if (i != 0) {
sum = prefixSumArr[j] - prefixSumArr[i - 1];
}
else
sum = prefixSumArr[j];
result += sum;
}
}
return result;
}
let arr = [ 1, 2, 3, 4 ];
let n = 4;
let ans = SubArraySum(arr, n);
console.log("Sum of SubArray : " + ans);
|
OutputSum of SubArray : 50
Time Complexity: O(N2)
Auxiliary Space: O(N)
Efficient Approach: To solve the problem follow the below idea:
If we take a close look then we observe a pattern.
Let’s 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
Follow the below steps to solve the problem:
- Declare an integer answer equal to zero
- Run a for loop for i [0, N]
- Add arr[i] * (i+1) * (N-i) into the answer at each iteration
- Return answer
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
long int SubArraySum(int arr[], int n)
{
long int result = 0;
for (int i = 0; i < n; i++)
result += (arr[i] * (i + 1) * (n - i));
return result;
}
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
class GFG {
public static long SubArraySum(int arr[], int n)
{
long result = 0;
for (int i = 0; i < n; i++)
result += (arr[i] * (i + 1) * (n - i));
return result;
}
public static void main(String[] args)
{
int arr[] = { 1, 2, 3 };
int n = arr.length;
System.out.println("Sum of SubArray "
+ SubArraySum(arr, n));
}
}
|
Python3
def SubArraySum(arr, n):
result = 0
for i in range(0, n):
result += (arr[i] * (i+1) * (n-i))
return result
arr = [1, 2, 3]
n = len(arr)
print("Sum of SubArray : ",
SubArraySum(arr, n))
|
C#
using System;
class GFG {
public static long SubArraySum(int[] arr, int n)
{
long result = 0;
for (int i = 0; i < n; i++)
result += (arr[i] * (i + 1) * (n - i));
return result;
}
static public void Main()
{
int[] arr = { 1, 2, 3 };
int n = arr.Length;
Console.WriteLine("Sum of SubArray: "
+ SubArraySum(arr, n));
}
}
|
PHP
<?php
function SubArraySum($arr , $n)
{
$result = 0;
for ($i = 0; $i < $n; $i++)
$result += ($arr[$i] *
($i + 1) *
($n - $i));
return $result ;
}
$arr = array(1, 2, 3) ;
$n = sizeof($arr);
echo "Sum of SubArray : ",
SubArraySum($arr, $n) ,"\n";
#This code is contributed by aj_36
?>
|
Javascript
<script>
function SubArraySum(arr, n)
{
let result = 0;
for(let i = 0; i < n; i++)
result += (arr[i] * (i + 1) *
(n - i));
return result ;
}
let arr = [ 1, 2, 3 ];
let n = arr.length;
document.write("Sum of SubArray : " +
SubArraySum(arr, n));
</script>
|
OutputSum of SubArray : 20
Time complexity: O(N)
Auxiliary Space: O(1)
This article is contributed by Nishant Singh. 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.