Related Articles
Sum of products of all combination taken (1 to n) at a time
• Difficulty Level : Hard
• Last Updated : 19 Oct, 2020

Given N, we have to find the sum of products of all combinations taken 1 to N at a time. In simple words, we have to find the sum of products of all combinations taken 1 at a time, then 2 at a time, then 3 at a time till N at a time.
If you think closely about the problem, a large value of N could result in producing many combinations.
Examples:

```Input :  N = 3
Output : f(1) = 6
f(2) = 11
f(3) = 6

Explanation: f(x) is sum of products of all
combination taken x at a time
1 + 2 + 3 = 6
f(2) = (1*2) + (1*3) + (2*3) = 11
f(3) = (1*2*3)

Input :  N = 4
Output : f(1) = 10
f(2) = 35
f(3) = 50
f(4) = 24

Explanation: f(1) = 1 + 2 + 3 + 4 = 10
f(2) = (1*2) + (1*3) + (1*4) +
(2*3) + (2*4) + (3*4)
= 35
f(3) = (1*2*3) + (1*2*4) +(1*3*4) +
(2*3*4)
= 50
f(4) = (1*2*3*4) = 24
```

A Brute force approach would be to produce all the combinations and then find their products and sum.
Recursion would do the trick to produce the combinations taken x at a time.
Example: N = 4 taken 3 at a time ## C++

 `// Program to find SOP of all combination taken` `// (1 to N) at a time using brute force` `#include ` `using` `namespace` `std;`   `// to store sum of every combination` `int` `sum = 0;`   `void` `Combination(``int` `a[], ``int` `combi[], ``int` `n, ` `                ``int` `r, ``int` `depth, ``int` `index) {`   `  ``// if we have reached sufficient depth` `  ``if` `(index == r) {` `    `  `    ``// find the product of combination` `    ``int` `product = 1;` `    ``for` `(``int` `i = 0; i < r; i++)` `      ``product = product * combi[i];`   `    ``// add the product into sum` `    ``sum += product;` `    ``return``;` `  ``}`   `  ``// recursion to produce different combination` `  ``for` `(``int` `i = depth; i < n; i++) {` `    ``combi[index] = a[i];` `    ``Combination(a, combi, n, r, i + 1, index + 1);` `  ``}` `}`   `// function to print sum of products of` `// all combination taken 1-N at a time` `void` `allCombination(``int` `a[], ``int` `n) {` `  ``for` `(``int` `i = 1; i <= n; i++) {`   `    ``// creating temporary array for storing` `    ``// combination` `    ``int` `*combi = ``new` `int``[i];`   `    ``// call combination with r = i` `    ``// for combination taken i at a time` `    ``Combination(a, combi, n, i, 0, 0);`   `    ``// displaying sum` `    ``cout << ``"f("` `<< i << ``") --> "` `<< sum << ``"\n"``;` `    ``sum = 0;`   `    ``// free from heap area` `    ``free``(combi);` `  ``}` `}`   `// Driver's code` `int` `main() {` `  ``int` `n = 5;` `  ``int` `*a = ``new` `int``[n];`   `  ``// storing numbers from 1-N in array` `  ``for` `(``int` `i = 0; i < n; i++)` `    ``a[i] = i + 1;`   `  ``// calling allCombination` `  ``allCombination(a, n);`   `  ``return` `0;` `}`

## Java

 `// Program to find SOP of ` `// all combination taken` `// (1 to N) at a time using` `// brute force` `import` `java.io.*;`   `class` `GFG` `{` `    ``// to store sum of` `    ``// every combination` `    ``static` `int` `sum = ``0``;` `    `  `    ``static` `void` `Combination(``int` `[]a, ``int` `[]combi, ` `                            ``int` `n, ``int` `r, ` `                            ``int` `depth, ``int` `index) ` `    ``{` `    `  `    ``// if we have reached` `    ``// sufficient depth` `    ``if` `(index == r) ` `    ``{` `        `  `        ``// find the product` `        ``// of combination` `        ``int` `product = ``1``;` `        ``for` `(``int` `i = ``0``; i < r; i++)` `        ``product = product * combi[i];` `    `  `        ``// add the product into sum` `        ``sum += product;` `        ``return``;` `    ``}` `    `  `    ``// recursion to produce ` `    ``// different combination` `    ``for` `(``int` `i = depth; i < n; i++) ` `    ``{` `        ``combi[index] = a[i];` `        ``Combination(a, combi, n, r, ` `                    ``i + ``1``, index + ``1``);` `    ``}` `    ``}` `    `  `    ``// function to print sum of ` `    ``// products of all combination` `    ``// taken 1-N at a time` `    ``static` `void` `allCombination(``int` `[]a, ` `                               ``int` `n)` `    ``{` `        ``for` `(``int` `i = ``1``; i <= n; i++) ` `        ``{` `        `  `            ``// creating temporary array ` `            ``// for storing combination` `            ``int` `[]combi = ``new` `int``[i];` `        `  `            ``// call combination with ` `            ``// r = i for combination ` `            ``// taken i at a time` `            ``Combination(a, combi, n,` `                        ``i, ``0``, ``0``);` `        `  `            ``// displaying sum` `            ``System.out.print(``"f("` `+ i + ``") --> "` `+ ` `                                      ``sum + ``"\n"``);` `            ``sum = ``0``;` `        ``}` `    ``}` `    `  `    ``// Driver code` `    ``public` `static` `void` `main(String args[]) ` `    ``{` `        ``int` `n = ``5``;` `        ``int` `[]a = ``new` `int``[n];` `        `  `        ``// storing numbers ` `        ``// from 1-N in array` `        ``for` `(``int` `i = ``0``; i < n; i++)` `            ``a[i] = i + ``1``;` `        `  `        ``// calling allCombination` `        ``allCombination(a, n);` `    ``}` `} `   `// This code is contributed by ` `// Manish Shaw(manishshaw1)`

## Python3

 `# Python3 Program to find SOP of all combination ` `# taken (1 to N) at a time using brute force `   `# to store sum of every combination ` `def` `Combination(a, combi, n, r, depth, index):` `    ``global` `Sum` `    `  `    ``# if we have reached sufficient depth ` `    ``if` `index ``=``=` `r: ` `    `  `        ``# find the product of combination ` `        ``product ``=` `1` `        ``for` `i ``in` `range``(r):` `            ``product ``=` `product ``*` `combi[i] ` `    `  `        ``# add the product into sum ` `        ``Sum` `+``=` `product ` `        ``return`   `    ``# recursion to produce different` `    ``# combination ` `    ``for` `i ``in` `range``(depth, n):` `        ``combi[index] ``=` `a[i] ` `        ``Combination(a, combi, n, r, ` `                    ``i ``+` `1``, index ``+` `1``)`   `# function to print sum of products of ` `# all combination taken 1-N at a time ` `def` `allCombination(a, n):` `    ``global` `Sum` `    ``for` `i ``in` `range``(``1``, n ``+` `1``):` `        `  `        ``# creating temporary array for ` `        ``# storing combination ` `        ``combi ``=` `[``0``] ``*` `i ` `    `  `        ``# call combination with r = i ` `        ``# for combination taken i at a time ` `        ``Combination(a, combi, n, i, ``0``, ``0``) ` `    `  `        ``# displaying sum ` `        ``print``(``"f("``, i, ``") --> "``, ``Sum``) ` `        ``Sum` `=` `0`   `# Driver Code ` `Sum` `=` `0` `n ``=` `5` `a ``=` `[``0``] ``*` `n `   `# storing numbers from 1-N in array` `for` `i ``in` `range``(n):` `    ``a[i] ``=` `i ``+` `1`   `# calling allCombination ` `allCombination(a, n) `   `# This code is contributed by PranchalK`

## C#

 `// Program to find SOP of ` `// all combination taken` `// (1 to N) at a time using` `// brute force` `using` `System;`   `class` `GFG` `{` `    ``// to store sum of` `    ``// every combination` `    ``static` `int` `sum = 0;` `    `  `    ``static` `void` `Combination(``int` `[]a, ``int` `[]combi, ` `                            ``int` `n, ``int` `r, ` `                            ``int` `depth, ``int` `index) ` `    ``{` `    `  `    ``// if we have reached` `    ``// sufficient depth` `    ``if` `(index == r) ` `    ``{` `        `  `        ``// find the product` `        ``// of combination` `        ``int` `product = 1;` `        ``for` `(``int` `i = 0; i < r; i++)` `        ``product = product * combi[i];` `    `  `        ``// add the product into sum` `        ``sum += product;` `        ``return``;` `    ``}` `    `  `    ``// recursion to produce ` `    ``// different combination` `    ``for` `(``int` `i = depth; i < n; i++) ` `    ``{` `        ``combi[index] = a[i];` `        ``Combination(a, combi, n, r, ` `                    ``i + 1, index + 1);` `    ``}` `    ``}` `    `  `    ``// function to print sum of ` `    ``// products of all combination` `    ``// taken 1-N at a time` `    ``static` `void` `allCombination(``int` `[]a, ` `                               ``int` `n)` `    ``{` `    ``for` `(``int` `i = 1; i <= n; i++) ` `    ``{` `    `  `        ``// creating temporary array ` `        ``// for storing combination` `        ``int` `[]combi = ``new` `int``[i];` `    `  `        ``// call combination with ` `        ``// r = i for combination ` `        ``// taken i at a time` `        ``Combination(a, combi, n,` `                    ``i, 0, 0);` `    `  `        ``// displaying sum` `        ``Console.Write(``"f("` `+ i + ``") --> "` `+ ` `                               ``sum + ``"\n"``);` `        ``sum = 0;` `    ``}` `    ``}` `    `  `    ``// Driver code` `    ``static` `void` `Main() ` `    ``{` `        ``int` `n = 5;` `        ``int` `[]a = ``new` `int``[n];` `        `  `        ``// storing numbers ` `        ``// from 1-N in array` `        ``for` `(``int` `i = 0; i < n; i++)` `            ``a[i] = i + 1;` `        `  `        ``// calling allCombination` `        ``allCombination(a, n);` `    ``}` `}`   `// This code is contributed by ` `// Manish Shaw(manishshaw1)`

Output:

```f(1) --> 15
f(2) --> 85
f(3) --> 225
f(4) --> 274
f(5) --> 120

```

The Time complexity of the above code is exponential when the value of N is large.
An Efficient Method is to use the concept of dynamic programming. We don’t have to find the sum of products every time. We can make use of previous results.
Let’s take an example: N = 4 ## C++

 `// CPP Program to find sum of all combination takne` `// (1 to N) at a time using dynamic programming` `#include ` `using` `namespace` `std;`   `// find the postfix sum array` `void` `postfix(``int` `a[], ``int` `n) {` `  ``for` `(``int` `i = n - 1; i > 0; i--)` `    ``a[i - 1] = a[i - 1] + a[i];` `}`   `// modify the array such that we don't have to` `// compute the products which are obtained before` `void` `modify(``int` `a[], ``int` `n) {` `  ``for` `(``int` `i = 1; i < n; i++)` `    ``a[i - 1] = i * a[i];` `}`   `// finding sum of all combination taken 1 to N at a time` `void` `allCombination(``int` `a[], ``int` `n) {`   `  ``int` `sum = 0;`   `  ``// sum taken 1 at time is simply sum of 1 - N` `  ``for` `(``int` `i = 1; i <= n; i++)` `    ``sum += i;` `  ``cout << ``"f(1) --> "` `<< sum << ``"\n"``;`   `  ``// for sum of products for all combination` `  ``for` `(``int` `i = 1; i < n; i++) {`   `    ``// finding postfix array` `    ``postfix(a, n - i + 1);` `    `  `    ``// sum of products taken i+1 at a time` `    ``sum = 0;` `    ``for` `(``int` `j = 1; j <= n - i; j++) {` `      ``sum += (j * a[j]);` `    ``}` `    ``cout << ``"f("` `<< i + 1 << ``") --> "` `<< sum << ``"\n"``;`   `    ``// modify the array for overlapping problem` `    ``modify(a, n);` `  ``}` `}`   `// Driver's Code` `int` `main() {` `  ``int` `n = 5;` `  ``int` `*a = ``new` `int``[n];`   `  ``// storing numbers from 1 to N` `  ``for` `(``int` `i = 0; i < n; i++)` `    ``a[i] = i + 1;`   `  ``// calling allCombination` `  ``allCombination(a, n);`   `  ``return` `0;` `}`

## Java

 `// Java Program to find sum of all combination takne` `// (1 to N) at a time using dynamic programming` `import` `java.util.*;`   `class` `GFG ` `{`   `    ``// find the postfix sum array` `    ``static` `void` `postfix(``int` `a[], ``int` `n) ` `    ``{` `        ``for` `(``int` `i = n - ``1``; i > ``0``; i--) ` `        ``{` `            ``a[i - ``1``] = a[i - ``1``] + a[i];` `        ``}` `    ``}`   `    ``// modify the array such that we don't ` `    ``// have to compute the products which` `    ``// are obtained before` `    ``static` `void` `modify(``int` `a[], ``int` `n)` `    ``{` `        ``for` `(``int` `i = ``1``; i < n; i++) ` `        ``{` `            ``a[i - ``1``] = i * a[i];` `        ``}` `    ``}`   `    ``// finding sum of all combination ` `    ``// taken 1 to N at a time` `    ``static` `void` `allCombination(``int` `a[], ``int` `n) ` `    ``{` `        ``int` `sum = ``0``;`   `        ``// sum taken 1 at time is simply sum of 1 - N` `        ``for` `(``int` `i = ``1``; i <= n; i++) ` `        ``{` `            ``sum += i;` `        ``}` `        ``System.out.println(``"f(1) --> "` `+ sum);`   `        ``// for sum of products for all combination` `        ``for` `(``int` `i = ``1``; i < n; i++) ` `        ``{`   `            ``// finding postfix array` `            ``postfix(a, n - i + ``1``);`   `            ``// sum of products taken i+1 at a time` `            ``sum = ``0``;` `            ``for` `(``int` `j = ``1``; j <= n - i; j++) ` `            ``{` `                ``sum += (j * a[j]);` `            ``}` `            ``System.out.println(``"f("` `+ (i + ``1``) + ` `                               ``") --> "` `+ sum);`   `            ``// modify the array for overlapping problem` `            ``modify(a, n);` `        ``}` `    ``}`   `    ``// Driver's Code` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``int` `n = ``5``;` `        ``int``[] a = ``new` `int``[n];`   `        ``// storing numbers from 1 to N` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{` `            ``a[i] = i + ``1``;` `        ``}`   `        ``// calling allCombination` `        ``allCombination(a, n);` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 Program to find ` `# sum of all combination takne` `# (1 to N) at a time using ` `# dynamic programming`   `# Find the postfix sum array` `def` `postfix(a, n):` `  `  `    ``for` `i ``in` `range` `(n ``-` `1``, ``1``, ``-``1``):` `        ``a[i ``-` `1``] ``=` `a[i ``-` `1``] ``+` `a[i]`   `# Modify the array such ` `# that we don't have to` `# compute the products ` `# which are obtained before` `def` `modify(a, n):` `  `  `    ``for` `i ``in` `range` `(``1``, n):` `        ``a[i ``-` `1``] ``=` `i ``*` `a[i];`   `# Finding sum of all combination ` `# taken 1 to N at a time` `def` `allCombination(a, n):`   `    ``sum` `=` `0`   `    ``# sum taken 1 at time is ` `    ``# simply sum of 1 - N` `    ``for` `i ``in` `range` `(``1``, n ``+` `1``):` `      `  `        ``sum` `+``=` `i` `    ``print` `(``"f(1) --> "``, ``sum` `)`   `    ``# for sum of products for ` `    ``# all combination` `    ``for` `i ``in` `range` `(``1``, n):`   `        ``# finding postfix array` `        ``postfix(a, n ``-` `i ``+` `1``)` `    `  `        ``# sum of products taken ` `        ``# i+1 at a time` `        ``sum` `=` `0` `        `  `        ``for` `j ``in` `range``(``1``, n ``-` `i ``+` `1``):` `            ``sum` `+``=` `(j ``*` `a[j])` `    `  `        ``print` `(``"f("``, i ``+` `1``, ``") --> "``, ``sum``)`   `        ``# modify the array for ` `        ``# overlapping problem` `        ``modify(a, n)`   `# Driver's Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``n ``=` `5` `    ``a ``=` `[``0``] ``*` `n`   `    ``# storing numbers ` `    ``# from 1 to N` `    ``for` `i ``in` `range``(n):` `        ``a[i] ``=` `i ``+` `1`   `    ``# calling allCombination` `    ``allCombination(a, n)`   `# This code is contributed by Chitranayal`

## C#

 `// C# Program to find sum of all combination takne` `// (1 to N) at a time using dynamic programming` `using` `System;` `    `  `class` `GFG ` `{`   `    ``// find the postfix sum array` `    ``static` `void` `postfix(``int` `[]a, ``int` `n) ` `    ``{` `        ``for` `(``int` `i = n - 1; i > 0; i--) ` `        ``{` `            ``a[i - 1] = a[i - 1] + a[i];` `        ``}` `    ``}`   `    ``// modify the array such that we don't ` `    ``// have to compute the products which` `    ``// are obtained before` `    ``static` `void` `modify(``int` `[]a, ``int` `n)` `    ``{` `        ``for` `(``int` `i = 1; i < n; i++) ` `        ``{` `            ``a[i - 1] = i * a[i];` `        ``}` `    ``}`   `    ``// finding sum of all combination ` `    ``// taken 1 to N at a time` `    ``static` `void` `allCombination(``int` `[]a, ``int` `n) ` `    ``{` `        ``int` `sum = 0;`   `        ``// sum taken 1 at time is simply sum of 1 - N` `        ``for` `(``int` `i = 1; i <= n; i++) ` `        ``{` `            ``sum += i;` `        ``}` `        ``Console.WriteLine(``"f(1) --> "` `+ sum);`   `        ``// for sum of products for all combination` `        ``for` `(``int` `i = 1; i < n; i++) ` `        ``{`   `            ``// finding postfix array` `            ``postfix(a, n - i + 1);`   `            ``// sum of products taken i+1 at a time` `            ``sum = 0;` `            ``for` `(``int` `j = 1; j <= n - i; j++) ` `            ``{` `                ``sum += (j * a[j]);` `            ``}` `            ``Console.WriteLine(``"f("` `+ (i + 1) + ` `                            ``") --> "` `+ sum);`   `            ``// modify the array for overlapping problem` `            ``modify(a, n);` `        ``}` `    ``}`   `    ``// Driver's Code` `    ``public` `static` `void` `Main(String[] args) ` `    ``{` `        ``int` `n = 5;` `        ``int``[] a = ``new` `int``[n];`   `        ``// storing numbers from 1 to N` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{` `            ``a[i] = i + 1;` `        ``}`   `        ``// calling allCombination` `        ``allCombination(a, n);` `    ``}` `}`   `// This code is contributed by Rajput-Ji`

Output:

```f(1) --> 15
f(2) --> 85
f(3) --> 225
f(4) --> 274
f(5) --> 120

```

The Time Complexity of the above method is O(n^2) which far better than the brute force method.
You can also find the execution time of both the method for a large value of N and can see the difference for yourself.

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.

My Personal Notes arrow_drop_up
Recommended Articles
Page :