# Print sums of all subsets of a given set

• Difficulty Level : Medium
• Last Updated : 08 Nov, 2021

Given an array of integers, print sums of all subsets in it. Output sums can be printed in any order.

Examples :

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.

```Input : arr[] = {2, 3}
Output: 0 2 3 5

Input : arr[] = {2, 4, 5}
Output : 0 2 4 5 6 7 9 11```

Method 1 (Recursive)
We can recursively solve this problem. There are total 2n subsets. For every element, we consider two choices, we include it in a subset and we don’t include it in a subset. Below is recursive solution based on this idea.

## C++

 `// C++ program to print sums of all possible``// subsets.``#include ``using` `namespace` `std;` `// Prints sums of all subsets of arr[l..r]``void` `subsetSums(``int` `arr[], ``int` `l, ``int` `r, ``int` `sum = 0)``{``    ``// Print current subset``    ``if` `(l > r) {``        ``cout << sum << ``" "``;``        ``return``;``    ``}` `    ``// Subset including arr[l]``    ``subsetSums(arr, l + 1, r, sum + arr[l]);` `    ``// Subset excluding arr[l]``    ``subsetSums(arr, l + 1, r, sum);``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 5, 4, 3 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``subsetSums(arr, 0, n - 1);``    ``return` `0;``}`

## Java

 `// Java program to print sums``// of all possible subsets.``import` `java.io.*;` `class` `GFG {` `    ``// Prints sums of all``    ``// subsets of arr[l..r]``    ``static` `void` `subsetSums(``int``[] arr, ``int` `l, ``int` `r, ``int` `sum)``    ``{` `        ``// Print current subset``        ``if` `(l > r) {``            ``System.out.print(sum + ``" "``);``            ``return``;``        ``}` `        ``// Subset including arr[l]``        ``subsetSums(arr, l + ``1``, r, sum + arr[l]);` `        ``// Subset excluding arr[l]``        ``subsetSums(arr, l + ``1``, r, sum);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = { ``5``, ``4``, ``3` `};``        ``int` `n = arr.length;` `        ``subsetSums(arr, ``0``, n - ``1``, ``0``);``    ``}``}` `// This code is contributed by anuj_67`

## Python3

 `# Python3 program to print sums of``# all possible subsets.` `# Prints sums of all subsets of arr[l..r]`  `def` `subsetSums(arr, l, r, ``sum``=``0``):` `    ``# Print current subset``    ``if` `l > r:``        ``print``(``sum``, end``=``" "``)``        ``return` `    ``# Subset including arr[l]``    ``subsetSums(arr, l ``+` `1``, r, ``sum` `+` `arr[l])` `    ``# Subset excluding arr[l]``    ``subsetSums(arr, l ``+` `1``, r, ``sum``)`  `# Driver code``arr ``=` `[``5``, ``4``, ``3``]``n ``=` `len``(arr)``subsetSums(arr, ``0``, n ``-` `1``)` `# This code is contributed by Shreyanshi Arun.`

## C#

 `// C# program to print sums of all possible``// subsets.``using` `System;` `class` `GFG {` `    ``// Prints sums of all subsets of``    ``// arr[l..r]``    ``static` `void` `subsetSums(``int``[] arr, ``int` `l, ``int` `r, ``int` `sum)``    ``{` `        ``// Print current subset``        ``if` `(l > r) {``            ``Console.Write(sum + ``" "``);``            ``return``;``        ``}` `        ``// Subset including arr[l]``        ``subsetSums(arr, l + 1, r, sum + arr[l]);` `        ``// Subset excluding arr[l]``        ``subsetSums(arr, l + 1, r, sum);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr = { 5, 4, 3 };``        ``int` `n = arr.Length;` `        ``subsetSums(arr, 0, n - 1, 0);``    ``}``}` `// This code is contributed by anuj_67`

## PHP

 ` ``\$r``)``    ``{``        ``echo` `\$sum` `, ``" "``;``        ``return``;``    ``}` `    ``// Subset including arr[l]``    ``subsetSums(``\$arr``, ``\$l` `+ 1, ``\$r``,``               ``\$sum` `+ ``\$arr``[``\$l``]);` `    ``// Subset excluding arr[l]``    ``subsetSums(``\$arr``, ``\$l` `+ 1, ``\$r``, ``\$sum``);``}` `// Driver code``\$arr` `= ``array``(5, 4, 3);``\$n` `= ``count``(``\$arr``);` `subsetSums(``\$arr``, 0, ``\$n` `- 1);` `// This code is contributed by anuj_67.``?>`

## Javascript

 ``

Output :

`12 9 8 5 7 4 3 0`

Time complexity of this solution is O(2^n) and space complexity is O(2^n).

Method 2 (Iterative)
As discussed above, there are total 2n subsets. The idea is generate loop from 0 to 2n – 1. For every number, pick all array elements which correspond to 1s in binary representation of current number.

## C++

 `// Iterative C++ program to print sums of all``// possible subsets.``#include ``using` `namespace` `std;` `// Prints sums of all subsets of array``void` `subsetSums(``int` `arr[], ``int` `n)``{``    ``// There are totoal 2^n subsets``    ``long` `long` `total = 1 << n;` `    ``// Consider all numbers from 0 to 2^n - 1``    ``for` `(``long` `long` `i = 0; i < total; i++) {``        ``long` `long` `sum = 0;` `        ``// Consider binary representation of``        ``// current i to decide which elements``        ``// to pick.``        ``for` `(``int` `j = 0; j < n; j++)``            ``if` `(i & (1 << j))``                ``sum += arr[j];` `        ``// Print sum of picked elements.``        ``cout << sum << ``" "``;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 5, 4, 3 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``subsetSums(arr, n);``    ``return` `0;``}`

## Java

 `// Iterative Java program to print sums of all``// possible subsets.``import` `java.util.*;` `class` `GFG {` `    ``// Prints sums of all subsets of array``    ``static` `void` `subsetSums(``int` `arr[], ``int` `n)``    ``{` `        ``// There are totoal 2^n subsets``        ``int` `total = ``1` `<< n;` `        ``// Consider all numbers from 0 to 2^n - 1``        ``for` `(``int` `i = ``0``; i < total; i++) {``            ``int` `sum = ``0``;` `            ``// Consider binary representation of``            ``// current i to decide which elements``            ``// to pick.``            ``for` `(``int` `j = ``0``; j < n; j++)``                ``if` `((i & (``1` `<< j)) != ``0``)``                    ``sum += arr[j];` `            ``// Print sum of picked elements.``            ``System.out.print(sum + ``" "``);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String args[])``    ``{``        ``int` `arr[] = ``new` `int``[] { ``5``, ``4``, ``3` `};``        ``int` `n = arr.length;` `        ``subsetSums(arr, n);``    ``}``}` `// This code is contributed by spp____`

## C#

 `// Iterative C# program to print sums of all``// possible subsets.``using` `System;``class` `GFG {``    ` `    ``// Prints sums of all subsets of array``    ``static` `void` `subsetSums(``int``[] arr, ``int` `n)``    ``{`` ` `        ``// There are totoal 2^n subsets``        ``int` `total = 1 << n;`` ` `        ``// Consider all numbers from 0 to 2^n - 1``        ``for` `(``int` `i = 0; i < total; i++) {``            ``int` `sum = 0;`` ` `            ``// Consider binary representation of``            ``// current i to decide which elements``            ``// to pick.``            ``for` `(``int` `j = 0; j < n; j++)``                ``if` `((i & (1 << j)) != 0)``                    ``sum += arr[j];`` ` `            ``// Print sum of picked elements.``            ``Console.Write(sum + ``" "``);``        ``}``    ``}``    ` `  ``static` `void` `Main() {``    ``int``[] arr = { 5, 4, 3 };``    ``int` `n = arr.Length;``    ` `    ``subsetSums(arr, n);``  ``}``}` `// This code is contributed by divyesh072019.`

## PHP

 ``

## Javascript

 ``

Output :

`0 5 4 9 3 8 7 12 `

Time Complexity: O( )
Auxiliary Space: O(1)
Thanks to cfh for suggesting above iterative solution in a comment.
Note: We haven’t actually created sub-sets to find their sums rather we have just used recursion to find sum of non-contiguous sub-sets of the given set.

The above mentioned techniques can be used to perform various operations on sub-sets like multiplication, division, XOR, OR, etc, without actually creating and storing the sub-sets and thus making the program memory efficient.