Given an array of integers, print sums of all subsets in it. Output sums can be printed in any order.
Examples :
Input: arr[] = {2, 3}
Output: 0 2 3 5
Explanation: All subsets of this array are - {{}, {2}, {3}, {2, 3}}, having sums - 0, 2, 3 and 5 respectively.
Input: arr[] = {2, 4, 5}
Output: 0 2 4 5 6 7 9 11
Try It Yourself
[Naive Approach] Using Iterative Method - O(N * 2^N) Time and O(1) Space
There are total 2n subsets. The idea is to generate a loop from 0 to 2n - 1. For every number, pick all array elements corresponding to 1s in the binary representation of the current number.
// Iterative C++ program to print sums of all
// possible subsets.
#include <bits/stdc++.h>
using namespace std;
// Prints sums of all subsets of array
void subsetSums(vector<int> &arr, int n)
{
// There are total 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()
{
vector<int> arr = { 5, 4, 3 };
int n = arr.size();
subsetSums(arr, n);
return 0;
}
// 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 total 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____
# Iterative Python3 program to print sums of all possible subsets
# Prints sums of all subsets of array
def subsetSums(arr, n):
# There are total 2^n subsets
total = 1 << n
# Consider all numbers from 0 to 2^n - 1
for i in range(total):
Sum = 0
# Consider binary representation of
# current i to decide which elements
# to pick.
for j in range(n):
if ((i & (1 << j)) != 0):
Sum += arr[j]
# Print sum of picked elements.
print(Sum, "", end = "")
arr = [ 5, 4, 3 ]
n = len(arr)
subsetSums(arr, n);
# This code is contributed by mukesh07.
// 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 total 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.
// Iterative Javascript program to print sums of all
// possible subsets.
// Prints sums of all subsets of array
function subsetSums(arr, n)
{
// There are total 2^n subsets
let total = 1 << n;
// Consider all numbers from 0 to 2^n - 1
for(let i = 0; i < total; i++)
{
let sum = 0;
// Consider binary representation of
// current i to decide which elements
// to pick.
for(let j = 0; j < n; j++)
if ((i & (1 << j)) != 0)
sum += arr[j];
// Print sum of picked elements.
process.stdout.write(sum + " ");
}
}
let arr = [ 5, 4, 3 ];
let n = arr.length;
subsetSums(arr, n);
Output :
0 5 4 9 3 8 7 12 [Expected Approach] Using Recursion - O(2^N) Time and O(N) Space
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++ program to print sums of all possible
// subsets.
#include <bits/stdc++.h>
using namespace std;
// Prints sums of all subsets of arr[l..r]
void subsetSums(vector<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()
{
vector<int> arr = { 5, 4, 3 };
int n = arr.size();
subsetSums(arr, 0, n - 1);
return 0;
}
// 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 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# 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
// Javascript program to program to print
// sums of all possible subsets.
// Prints sums of all
// subsets of arr[l..r]
function subsetSums(arr, l, r, sum, result)
{
// Print current subset
if (l > r)
{
result.push(sum);
return;
}
// Subset including arr[l]
subsetSums(arr, l + 1, r,
sum + arr[l],result);
// Subset excluding arr[l]
subsetSums(arr, l + 1, r, sum,result);
}
// Driver code
let arr = [5, 4, 3];
let n = arr.length;
let result = [];
subsetSums(arr, 0, n - 1, 0,result);
console.log(result.join(" "));
// This code is contributed by code_hunt
Output :
12 9 8 5 7 4 3 0[Alternate Approach] Using Iterative method - O(2^N) Time and O(N) Space
In this method, while visiting a new element, we take its sum with all previously stored sums. This method stores the sums of all subsets and hence it is valid for smaller inputs.
// Iterative C++ program to print sums of all
// possible subsets.
#include <bits/stdc++.h>
using namespace std;
// Prints sums of all subsets of array
void subsetSums(vector<int> &nums, int n)
{
// There are total 2^n subsets
vector<int> s = {0};//store the sums
for (int i = 0; i <n; i++) {
const int v = s.size();
for (int t = 0; t < v; t++) {
s.push_back(s[t] + nums[i]); //add this element with previous subsets
}
}
// Print
for(int i=0;i<s.size();i++)
cout << s[i] << " ";
}
// Driver code
int main()
{
vector<int> arr = { 5, 4, 3 };
int n = arr.size();
subsetSums(arr, n);
return 0;
}
import java.util.ArrayList;
public class Main {
public static void subsetSums(int[] nums, int n) {
ArrayList<Integer> s = new ArrayList<Integer>();
s.add(0);
for (int i = 0; i < n; i++) {
int v = s.size();
for (int t = 0; t < v; t++) {
s.add(s.get(t) + nums[i]);
}
}
for (int i = 0; i < s.size(); i++) {
System.out.print(s.get(i) + " ");
}
}
public static void main(String[] args) {
int[] arr = { 5, 4, 3 };
int n = arr.length;
subsetSums(arr, n);
}
}
# Iterative Python program to print sums of all
# possible subsets.
# Prints sums of all subsets of array
def subsetSums(nums,n):
# There are total 2^n subsets
s = [0]
for i in range(n):
v = len(s)
for t in range(v):
s.append(s[t] + nums[i]) # add this element with previous subsets
# Print
for i in s:
print(i, end=" ")
# Driver code
arr = [5, 4, 3 ]
n = len(arr)
subsetSums(arr, n)
// C# program to print sums of all possible subsets
using System;
public class Subsets
{
static void subsetSums(int[] nums, int n)
{
// There are total 2^n subsets
int[] s = new int[1];
s[0] = 0;
for (int i = 0; i < n; i++)
{
int v = s.Length;
for (int t = 0; t < v; t++)
{
// add the current element with all previous subsets
Array.Resize(ref s, s.Length + 1); // increase the size of the array
s[s.Length - 1] = s[t] + nums[i]; // add the current element with previous subsets
}
}
// Print
Console.Write(string.Join(" ", s));
}public static void Main()
{
int[] arr = { 5, 4, 3 };
int n = arr.Length;
subsetSums(arr, n);
}
}
// Iterative JavaScript program to print sums of all possible subsets
function subsetSums(nums, n) {
// There are total 2^n subsets
let s = [0];
for (let i = 0; i < n; i++) {
let v = s.length;
for (let t = 0; t < v; t++) {
s.push(s[t] + nums[i]); // add this element with previous subsets
}
}
// Print
for (let i=0; i<s.length; i++) {
process.stdout.write(s[i]+" ");
}
}
// Driver code
let arr = [5, 4, 3];
let n = arr.length;
subsetSums(arr, n);
Output:
0 5 4 9 3 8 7 12 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.