Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Sum of all subsequences of a number

  • Difficulty Level : Easy
  • Last Updated : 06 May, 2021

Given a number as string s, find the sum of all the elements present in all possible subsequences of s.
Examples : 
 

Input : s = "123" 
Output : 24 
Explanation : all possible sub-sequences are 
1, 2, 3, {1, 2}, {2, 3}, {1, 3}, {1, 2, 3} 
which add up to 24 

Input : s = "453" 
Output : 48

 

Approach : Using power set, we can find all the subsequences and sum up all the subsequences individually in a different function. The total number of subsequences possible are 2n-1. Add the sum of all subsequences to the combined sum which is the final output. 
Below is the implementation of above approach. 
 

C++




// CPP program to find the sum of
// elements present in all subsequences
#include <bits/stdc++.h>
using namespace std;
 
// Returns numeric value of a subsequence of
// s. The subsequence to be picked is decided
// using bit pattern of num (We pick all those
// digits for which there is a set bit in num)
int findSubSequence(string s, int num)
{ 
    // Initialize the result
    int res = 0;
 
    // till n!=0
    int i = 0;
    while (num) {
         
        // if i-th bit is set
        // then add this number
        if (num & 1)
            res += s[i] - '0';
        i++;
         
        // right shift i
        num = num >> 1;
    }
 
    return res;
}
 
// function to find combined sum
// of all individual subsequence sum
int combinedSum(string s)
{
    // length of string
    int n = s.length();
     
    // stores the combined
    int c_sum = 0;
 
    // 2^n-1 subsequences
    int range = (1 << n) - 1;
 
    // loop for all subsequences
    for (int i = 0; i <= range; i++)
        c_sum += findSubSequence(s, i);
 
    // returns the combined sum
    return c_sum;
}
 
// driver code
int main()
{
    string s = "123";
    cout << combinedSum(s);   
    return 0;
}
Java



// Java program to find the sum of elements
// present in all subsequences
import java.io.*;
 
class GFG {
     
    // Returns numeric value of a
    // subsequence of s. The subsequence
    // to be picked is decided using bit
    // pattern of num (We pick all those
    // digits for which there is a set
    // bit in num)
    static int findSubSequence(String s,
                                int num)
    {
        // Initialize the result
        int res = 0;
     
        // till n!=0
        int i = 0;
        while (num > 0) {
             
            // if i-th bit is set
            // then add this number
            if ((num & 1) == 1)
                res += s.charAt(i) - '0';
            i++;
             
            // right shift i
            num = num >> 1;
        }
     
        return res;
    }
 
    // function to find combined sum
    // of all individual subsequence
    // sum
    static int combinedSum(String s)
    {
         
        // length of String
        int n = s.length();
         
        // stores the combined
        int c_sum = 0;
     
        // 2^n-1 subsequences
        int range = (1 << n) - 1;
     
        // loop for all subsequences
        for (int i = 0; i <= range; i++)
            c_sum += findSubSequence(s, i);
     
        // returns the combined sum
        return c_sum;
    }
 
    // Driver function
    public static void main (String[] args) {
     
        String s = "123";
        System.out.println(combinedSum(s));
    }
 
}
 
// This code is contributed by Anuj_ 67
Python 3



# Python 3 program to find the sum of
# elements present in all subsequences
  
# Returns numeric value of a subsequence of
# s. The subsequence to be picked is decided
# using bit pattern of num (We pick all those
# digits for which there is a set bit in num)
def findSubSequence(s, num):
 
    # Initialize the result
    res = 0
  
    # till n!=0
    i = 0
    while (num) :
          
        # if i-th bit is set
        # then add this number
        if (num & 1):
            res += ord(s[i]) - ord('0')
        i+=1
          
        # right shift i
        num = num >> 1
  
    return res
  
# function to find combined sum
# of all individual subsequence sum
def combinedSum(s):
 
    # length of string
    n = len(s)
      
    # stores the combined
    c_sum = 0
  
    # 2^n-1 subsequences
    ran = (1 << n) - 1
  
    # loop for all subsequences
    for i in range( ran+1):
        c_sum += findSubSequence(s, i)
  
    # returns the combined sum
    return c_sum
  
# driver code
if __name__ == "__main__":
     
    s = "123"
    print(combinedSum(s))
C#



// C# program to find the sum of elements
// present in all subsequences
using System;
 
class GFG {
     
    // Returns numeric value of a
    // subsequence of s. The subsequence
    // to be picked is decided using bit
    // pattern of num (We pick all those
    // digits for which there is a set
    // bit in num)
    static int findSubSequence(string s,
                                 int num)
    {
        // Initialize the result
        int res = 0;
     
        // till n!=0
        int i = 0;
        while (num > 0) {
             
            // if i-th bit is set
            // then add this number
            if ((num & 1) == 1)
                res += s[i] - '0';
            i++;
             
            // right shift i
            num = num >> 1;
        }
     
        return res;
    }
 
    // function to find combined sum
    // of all individual subsequence
    // sum
    static int combinedSum(string s)
    {
         
        // length of string
        int n = s.Length;
         
        // stores the combined
        int c_sum = 0;
     
        // 2^n-1 subsequences
        int range = (1 << n) - 1;
     
        // loop for all subsequences
        for (int i = 0; i <= range; i++)
            c_sum += findSubSequence(s, i);
     
        // returns the combined sum
        return c_sum;
    }
 
    // Driver function
    public static void Main()
    {
        string s = "123";
        Console.Write(combinedSum(s));
    }
 
}
 
// This code is contributed by Sam007
PHP



<?php
// PHP program to find the sum of
// elements present in all subsequences
 
// Returns numeric value of a subsequence of
// s. The subsequence to be picked is decided
// using bit pattern of num (We pick all those
// digits for which there is a set bit in num)
function findSubSequence($s, $num)
{
     
    // Initialize the result
    $res = 0;
 
    // till n!=0
    $i = 0;
    while ($num) {
         
        // if i-th bit is set
        // then add this number
        if ($num & 1)
            $res += $s[$i] - '0';
        $i++;
         
        // right shintift i
        $num = $num >> 1;
    }
 
    return $res;
}
 
// function to find combined sum
// of all individual subsequence sum
function combinedSum(string $s)
{
     
    // length of string
    $n = strlen($s);
     
    // stores the combined
    $c_sum = 0;
 
    // 2^n-1 subsequences
    $range = (1 << $n) - 1;
 
    // loop for all subsequences
    for ($i = 0; $i <= $range; $i++)
        $c_sum += findSubSequence($s, $i);
 
    // returns the combined sum
    return $c_sum;
}
 
    // Driver Code
    $s = "123";
    echo combinedSum($s);
     
// This code is contributed by Anuj_67
?>
Javascript



<script>
// Javascript program to find the sum of elements
// present in all subsequences
     
    // Returns numeric value of a
    // subsequence of s. The subsequence
    // to be picked is decided using bit
    // pattern of num (We pick all those
    // digits for which there is a set
    // bit in num)
    function findSubSequence(s,num)
    {
        // Initialize the result
        let res = 0;
       
        // till n!=0
        let i = 0;
        while (num > 0) {
               
            // if i-th bit is set
            // then add this number
            if ((num & 1) == 1)
                res += s[i].charCodeAt(0) - '0'.charCodeAt(0);
            i++;
               
            // right shift i
            num = num >> 1;
        }
       
        return res;
    }
     
    // function to find combined sum
    // of all individual subsequence
    // sum
    function combinedSum(s)
    {
        // length of String
        let n = s.length;
           
        // stores the combined
        let c_sum = 0;
       
        // 2^n-1 subsequences
        let range = (1 << n) - 1;
       
        // loop for all subsequences
        for (let i = 0; i <= range; i++)
            c_sum += findSubSequence(s, i);
       
        // returns the combined sum
        return c_sum;
    }
     
    // Driver function
    let s = "123";
    document.write(combinedSum(s));
     
     
    // This code is contributed by avanitrachhadiya2155
</script>
Output: 
 
24 
 

My Personal Notes
arrow_drop_up
Previous
Iterative program to Calculate Size of a tree
Next

Design City Guide System like Foursquare
Recommended Articles
Page :
Find product of all elements at indexes which are factors of M for all possible sorted subsequences of length M
09, May 20
Sum of all subsequences of an array
27, Aug 17
Sum of width (max and min diff) of all Subsequences
12, Nov 18
Find all combinations of two equal sum subsequences
24, Jul 19
Find all subsequences with sum equals to K
08, Apr 20
Sum of all subsequences of length K
24, May 20
Bitwise OR of sum of all subsequences of an array
09, Nov 20
Print all possible K-length subsequences of first N natural numbers with sum N
02, Dec 20
Minimum sum of medians of all possible K length subsequences of a sorted array
13, May 21
Count of subsequences with sum two less than the array sum
04, Nov 21
Number of subsequences with zero sum
16, Apr 19
Number of Subsequences with Even and Odd Sum
12, Aug 19
Number of Subsequences with Even and Odd Sum | Set 2
04, Sep 19
Number of K length subsequences with minimum sum
18, Oct 19
Given a number as a string, find the number of contiguous subsequences which recursively add up to 9
30, Jul 14
Given a number as a string, find the number of contiguous subsequences which recursively add up to 9 | Set 2
04, Jul 17
Count all increasing subsequences
07, Oct 16
Print all Subsequences of String which Start with Vowel and End with Consonant.
24, Aug 17
Generating all possible Subsequences using Recursion including the empty one.
03, Oct 18
Make all array elements equal to 0 by replacing minimum subsequences consisting of equal elements
13, Jan 21
Print all subsequences of a string using ArrayList
02, Jan 19
Product of all Subsequences of size K except the minimum and maximum Elements
18, Apr 19
Check if a string can be emptied by removing all subsequences of the form "10"
08, Feb 21
Print all subsequences of a string in Python
30, Mar 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ChetnaAgarwal
@ChetnaAgarwal
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!