Skip to content
Related Articles

Related Articles

Improve Article

Count of unique subsequences from given number which are power of 2

  • Last Updated : 07 Aug, 2021

Given a string S of size N and containing digits in the range [0-9], the task is to print the count of all the unique subsequences of a string that are the power of 2.

Examples:

Input: S = “1216389”
Output: 5
Explanation:
All the possible unique subsequences that are power of 2 are: {1, 2, 16, 128, 8}

Input: S = “12”
Output: 2
Explanation:
All the possible unique subsequences that are power of 2 are: {1, 2}.

Approach: The problem can be solved by generating all the subsequences of the string S and then checking if the number is the power of 2 or not. Follow the steps below to solve the problem:



  • Initialize a set say, allUniqueSubSeq to store the subsequence, which is a power of 2.
  • Define a recursive function, say uniqueSubSeq(S, ans, index), and perform the following steps:
    • Base Case: If the index is equal to N, then if, (int)ans, is the power of 2, then insert ans into the set allUniqueSubSeq.
    • Otherwise, there are two cases:
      • If S[index] is appended in the string ans, then recall the function uniqueSubSeq with parameters S, ans + S[index], and index+1.
      • If S[index] is not appended in the string ans, then recall the function uniqueSubSeq with parameters S, ans, and index + 1.
  • Finally, after performing the above steps, call the function, uniqueSubSeq(S, “”,  0) and then print the allUniqueSubSeq.size() as the answer.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Set to store subsequences that are
// power of 2
unordered_set<string> allUniqueSubSeq;
 
// Function to check whether the number
// is power of 2 or not
bool checkpower(int n)
{
    if ((n & (n - 1)) == 0)
    {
        return true;
    }
    return false;
}
 
// Auxiliary recursive Function to find
// all the unique subsequences of a string
// that are the power of 2
void uniqueSubSeq(string S, int N, string ans,
                            int index)
{
     
    // If index is equal to N
    if (index == N)
    {
        if (ans.length() != 0)
 
            // If the number is
            // power of 2
            if (checkpower(stoi(ans)))
            {
                 
                // Insert the String
                // in the set
                allUniqueSubSeq.insert(ans);
            }
        return;
    }
 
    // Recursion call, if the S[index]
    // is inserted in ans
    uniqueSubSeq(S, N, ans + S[index], index + 1);
 
    // Recursion call, if S[index] is
    // not inserted in ans
    uniqueSubSeq(S, N, ans, index + 1);
}
 
// Function to find count of all the unique
// subsequences of a string that are the
// power of 2
int Countsubsequneces(string S, int N)
{
     
    // Function Call
    uniqueSubSeq(S, N, "", 0);
 
    // Return the length of set
    // allUniqueSubSeq
    return allUniqueSubSeq.size();
}
 
// Driver Code
int main()
{
     
    // Given Input
    string S = "1216389";
    int N = S.length();
     
    // Function call
    cout << Countsubsequneces(S, N);
     
    return 0;
}
 
// This code is contributed by maddler

Java




// Java program for the above approach
import java.io.*;
import java.util.*;
public class main {
 
    // Set to store subsequences that are
    // power of 2
    static HashSet<String> allUniqueSubSeq
        = new HashSet<>();
 
    // Function to check whether the number
    // is power of 2 or not
    static boolean checkpower(int n)
    {
        if ((n & (n - 1)) == 0) {
            return true;
        }
        return false;
    }
 
    // Auxiliary recursive Function to find
    // all the unique subsequences of a string
    // that are the power of 2
    static void uniqueSubSeq(String S, int N, String ans,
                             int index)
    {
 
        // If index is equal to N
        if (index == N) {
 
            if (ans.length() != 0)
 
                // If the number is
                // power of 2
                if (checkpower(
                        Integer.parseInt(ans.trim()))) {
 
                    // Insert the String
                    // in the set
                    allUniqueSubSeq.add(ans);
                }
            return;
        }
 
        // Recursion call, if the S[index]
        // is inserted in ans
        uniqueSubSeq(S, N, ans + S.charAt(index),
                     index + 1);
 
        // Recursion call, if S[index] is
        // not inserted in ans
        uniqueSubSeq(S, N, ans, index + 1);
    }
 
    // Function to find count of all the unique
    // subsequences of a string that are the
    // power of 2
    static int Countsubsequneces(String S, int N)
    {
        // Function Call
        uniqueSubSeq(S, N, "", 0);
 
        // Return the length of set
        // allUniqueSubSeq
        return allUniqueSubSeq.size();
    }
 
    // Driver Code
    public static void main(String[] args)
    {
 
        // Given Input
        String S = "1216389";
        int N = S.length();
 
        // Function call
        System.out.println(Countsubsequneces(S, N));
    }
}

Python3




# Python program for the above approach
 
# Set to store subsequences that are
# power of 2
allUniqueSubSeq = set()
 
# Function to check whether the number
# is power of 2 or not
def checkpower(n):
    if(n & (n-1) == 0):
        return True
    return False
 
# Auxiliary recursive Function to find
# all the unique subsequences of a string
# that are the power of 2
def uniqueSubSeq(S, N, ans, index):
   
    # If index is equal to N
    if (index == N):
        if (len(ans) != 0):
           
            # If the number is
            # power of 2
            if(checkpower(int(ans))):
                allUniqueSubSeq.add(ans)
        return
       
    # Recursion call, if the S[index]
    # is inserted in ans
    uniqueSubSeq(S, N, ans+S[index], index+1)
     
    # Recursion call, if the S[index]
    # is not inserted in ans
    uniqueSubSeq(S, N, ans, index+1)
 
# Function to find count of all the unique
# subsequences of a string that are
# the power of 2
def countSubsequences(S, N):
   
    # Function call
    uniqueSubSeq(S, N, "", 0)
     
    # Return the length of set
    # allUniqueSubSeq
    return len(allUniqueSubSeq)
 
# Driver code
if __name__ == '__main__':
   
    # Given Input
    S = "1216389"
    N = len(S)
 
    # Function call
    print(countSubsequences(S, N))
     
# This code is contributed by MuskanKalra1

C#




using System;
using System.Collections.Generic;
public class GFG {
 
    // Set to store subsequences that are
    // power of 2
    static HashSet<String> allUniqueSubSeq
        = new HashSet<String>();
 
    // Function to check whether the number
    // is power of 2 or not
    static bool checkpower(int n)
    {
        if ((n & (n - 1)) == 0) {
            return true;
        }
        return false;
    }
 
    // Auxiliary recursive Function to find
    // all the unique subsequences of a string
    // that are the power of 2
    static void uniqueSubSeq(String S, int N, String ans,
                             int index)
    {
 
        // If index is equal to N
        if (index == N) {
 
            if (ans.Length != 0)
 
                // If the number is
                // power of 2
                if (checkpower(
                        int.Parse(ans))) {
 
                    // Insert the String
                    // in the set
                    allUniqueSubSeq.Add(ans);
                }
            return;
        }
 
        // Recursion call, if the S[index]
        // is inserted in ans
        uniqueSubSeq(S, N, ans + S[index],
                     index + 1);
 
        // Recursion call, if S[index] is
        // not inserted in ans
        uniqueSubSeq(S, N, ans, index + 1);
    }
 
    // Function to find count of all the unique
    // subsequences of a string that are the
    // power of 2
    static int Countsubsequeneces(String S, int N)
    {
        // Function Call
        uniqueSubSeq(S, N, "", 0);
 
        // Return the length of set
        // allUniqueSubSeq
        return allUniqueSubSeq.Count;
    }
 
    // Driver Code
 
    static public void Main()
    {
        String S = "1216389";
        int N = S.Length;
 
        // Function call
        Console.WriteLine(Countsubsequeneces(S, N));
    }
}
 
// This code is contributed by maddler.

Javascript




<script>
       // Javascript program for above approach
 
       // Set to store subsequences that are
       // power of 2
       const allUniqueSubSeq
           = new Set();
 
       // Function to check whether the number
       // is power of 2 or not
       function checkpower(n) {
           if ((n & (n - 1)) == 0) {
               return true;
           }
           return false;
       }
 
       // Auxiliary recursive Function to find
       // all the unique subsequences of a string
       // that are the power of 2
       function uniqueSubSeq(S, N, ans, index) {
 
           // If index is equal to N
           if (index == N) {
 
               if (ans.length != 0)
 
                   // If the number is
                   // power of 2
                   if (checkpower(parseInt(ans.trim()))) {
 
                       // Insert the String
                       // in the set
                       allUniqueSubSeq.add(ans);
                   }
               return;
           }
 
           // Recursion call, if the S[index]
           // is inserted in ans
           uniqueSubSeq(S, N, ans + S.charAt(index),
               index + 1);
 
           // Recursion call, if S[index] is
           // not inserted in ans
           uniqueSubSeq(S, N, ans, index + 1);
       }
 
       // Function to find count of all the unique
       // subsequences of a string that are the
       // power of 2
       function Countsubsequneces(S, N) {
           // Function Call
           uniqueSubSeq(S, N, "", 0);
 
           // Return the length of set
           // allUniqueSubSeq
           return allUniqueSubSeq.size;
       }
 
       // Driver Code
 
       // Given Input
       let S = "1216389";
       let N = S.length;
 
       // Function call
       document.write(Countsubsequneces(S, N));
 
       // This code is contributed by Hritik
   </script>
Output
5

Time Complexity: O(2N)
Auxiliary Space: O(2N)

 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :