# Permutations of a given number that are a powers of 2

• Difficulty Level : Medium
• Last Updated : 15 Jun, 2022

Given a string S consisting of N digits, the task is to print all possible combinations of the digits of the S that is a perfect power of 2.

Examples:

Input: S = “614”
Output: 4
Explanation:
All possible combinations of digit of S that are perfect power of 2 are 1, 4, 16, 64.

Input: S = “6”
Output: 0

Approach: The given problem can be solved by using Backtracking. The idea is to generate all possible permutations of the string S if it is a perfect power of 2 then print it. Follow the steps below to solve the problem:

• Define a function check(int number) to check if the given number is a power of 2 and perform the following tasks:
• If the number is equal to 0, then return false.
• If the Bitwise AND of number and number-1, then return true, else return false.
• Define a function calculate(int arr[], string ans) and perform the following tasks:
• If the length of the string ans is not equal to 0 and the value of the function. check(Integer.parseInt(ans.trim())) returns true, then add this value to the HashSet H[].
• Iterate over a range [0, 10] using the variable i and perform the following tasks:
• If arr[i] is equal to 0, then continue.
• Else, decrease the value of arr[i] by 1 and call the function calculate(temp, “”) to find the other possible permutations of the string str and add the value of arr[i] by 1.
• Initialize a HashSet H[] to store the possible string numbers which are a power of 2.
• Initialize an array, say temp[] to store the frequencies of the integers in the string str.
• Iterate in a while loop till N is not equal to 0 and perform the following steps:
• Initialize the variable rem as N%10 and increase the value of temp[rem] by 1.
• Divide the value of N by 10.
• Call the function calculate(temp, “”) to find the possible permutations of the string S.
• After performing the above steps, print the HashSet as the result.

Below is the implementation of the above approach.

## C++

 `#include ``using` `namespace` `std;` `// Stores the all possible generated``// integers from the given string``unordered_set<``int``> hs;` `// Function to check if the``// number is power of 2``bool` `check(``int` `number)``{``    ``// If number is 0, then it``    ``// can't be a power of 2``    ``if` `(number == 0) {``        ``return` `false``;``    ``}` `    ``// If the bitwise AND of n``    ``// and n-1 is 0, then only``    ``// it is a power of 2``    ``if` `((number & (number - 1)) == 0) {``        ``return` `true``;``    ``}` `    ``return` `false``;``}` `// Function to generate the numbers``void` `calculate(``int``* arr, string ans)``{` `    ``if` `(ans.length() != 0) {` `        ``// Checking the number``        ``if` `(check(stoi(ans))) {``            ``hs.insert(stoi(ans));``        ``}``    ``}` `    ``// Iterate over the range``    ``for` `(``int` `i = 0; i < 10; ++i) {` `        ``if` `(arr[i] == 0) {``            ``continue``;``        ``}` `        ``else` `{` `            ``// Use the number``            ``arr[i]--;``            ``calculate(arr,(ans +  to_string(i)));` `            ``// Backtracking Step``            ``arr[i]++;``        ``}``    ``}``}` `// Function to find the all possible``// permutations``void` `generatePermutation(``int` `n)``{``    ``hs.clear();``    ``// Stores the frequency of digits``    ``int` `temp;``    ``for` `(``int` `i = 0; i < 10; i++) {``        ``temp[i] = 0;``    ``}` `    ``// Iterate over the number``    ``while` `(n != 0) {``        ``int` `rem = n % 10;``        ``temp[rem]++;``        ``n = n / 10;``    ``}` `    ``// Function Call``    ``calculate(temp, ``""``);` `    ``// Print the result``    ``cout << hs.size() << ``"\n"``;``    ``for` `(``auto` `i : hs) {``        ``cout << i << ``" "``;``    ``}``}` `int` `main()``{` `    ``int` `N = 614;``    ``generatePermutation(N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;` `public` `class` `GFG {` `    ``// Stores the all possible generated``    ``// integers from the given string``    ``static` `HashSet H = ``new` `HashSet<>();` `    ``// Function to check if the``    ``// number is power of 2``    ``static` `boolean` `check(``int` `number)``    ``{``        ``// If number is 0, then it``        ``// can't be a power of 2``        ``if` `(number == ``0``) {``            ``return` `false``;``        ``}` `        ``// If the bitwise AND of n``        ``// and n-1 is 0, then only``        ``// it is a power of 2``        ``if` `((number & (number - ``1``)) == ``0``) {``            ``return` `true``;``        ``}` `        ``return` `false``;``    ``}` `    ``// Function to generate the numbers``    ``static` `void` `calculate(``        ``int` `arr[], String ans)``    ``{` `        ``if` `(ans.length() != ``0``) {` `            ``// Checking the number``            ``if` `(check(Integer.parseInt(``                    ``ans.trim()))) {``                ``H.add(Integer.parseInt(``                    ``ans.trim()));``            ``}``        ``}` `        ``// Iterate over the range``        ``for` `(``int` `i = ``0``; i < arr.length; ++i) {` `            ``if` `(arr[i] == ``0``) {``                ``continue``;``            ``}` `            ``else` `{` `                ``// Use the number``                ``arr[i]--;``                ``calculate(arr, ans + i);` `                ``// Backtracking Step``                ``arr[i]++;``            ``}``        ``}``    ``}` `    ``// Function to find the all possible``    ``// permutations``    ``static` `void` `generatePermutation(``int` `n)``    ``{``        ``// Stores the frequency of digits``        ``int` `temp[] = ``new` `int``[``10``];` `        ``// Iterate over the number``        ``while` `(n != ``0``) {``            ``int` `rem = n % ``10``;``            ``temp[rem]++;``            ``n = n / ``10``;``        ``}` `        ``// Function Call``        ``calculate(temp, ``""``);` `        ``// Print the result``        ``System.out.println(H.size());``        ``System.out.println(H);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``614``;``        ``generatePermutation(N);``    ``}``}`

## Python3

 `# Python3 program for the above approach` `# Stores the all possible generated``# integers from the given string``H ``=` `set``()` `# Function to check if the``# number is power of 2``def` `check(number):``  ` `    ``# If number is 0, then it``    ``# can't be a power of 2``    ``if` `(number ``=``=` `0``):``        ``return` `False` `    ``# If the bitwise AND of n``    ``# and n-1 is 0, then only``    ``# it is a power of 2``    ``if` `((number & (number ``-` `1``)) ``=``=` `0``):``        ``return` `True` `    ``return` `False` `# Function to generate the numbers``def` `calculate(arr, ans):``    ``if` `(``len``(ans) !``=` `0``):``        ``# Checking the number``        ``if` `(check(``int``(ans))):``            ``H.add(``int``(ans))` `    ``# Iterate over the range``    ``for` `i ``in` `range``(``len``(arr)):``        ``if` `(arr[i] ``=``=` `0``):``            ``continue``        ``else``:``            ``# Use the number``            ``arr[i]``-``=``1``            ``calculate(arr, ans ``+` `str``(i))` `            ``# Backtracking Step``            ``arr[i]``+``=``1` `# Function to find the all possible``# permutations``def` `generatePermutation(n):``  ` `    ``# Stores the frequency of digits``    ``h ``=` `[``16``, ``64``, ``1``, ``4``]``    ``temp ``=` `[``0``]``*``(``10``)` `    ``# Iterate over the number``    ``while` `(n !``=` `0``):``        ``rem ``=` `n ``%` `10``        ``temp[rem]``+``=``1``        ``n ``=` `int``(n ``/` `10``)` `    ``# Function Call``    ``calculate(temp, "")` `    ``# Print the result``    ``print``(``len``(H))``    ``print``(h)` `N ``=` `614``generatePermutation(N)` `# This code is contributed by divyesh072019.`

## C#

 `using` `System;``using` `System.Collections.Generic;``public` `class` `GFG{` `  ``// Stores the all possible generated``    ``// integers from the given string``    ``static` `HashSet<``int``> H = ``new` `HashSet<``int``>();` `    ``// Function to check if the``    ``// number is power of 2``    ``static` `bool` `check(``int` `number)``    ``{``        ``// If number is 0, then it``        ``// can't be a power of 2``        ``if` `(number == 0) {``            ``return` `false``;``        ``}` `        ``// If the bitwise AND of n``        ``// and n-1 is 0, then only``        ``// it is a power of 2``        ``if` `((number & (number - 1)) == 0) {``            ``return` `true``;``        ``}` `        ``return` `false``;``    ``}` `    ``// Function to generate the numbers``    ``static` `void` `calculate(``        ``int``[] arr, String ans)``    ``{` `        ``if` `(ans.Length != 0) {` `            ``// Checking the number``            ``if` `(check(``int``.Parse(``                    ``ans))) {``                ``H.Add(``int``.Parse(``                    ``ans));``            ``}``        ``}` `        ``// Iterate over the range``        ``for` `(``int` `i = 0; i < arr.Length; ++i) {` `            ``if` `(arr[i] == 0) {``                ``continue``;``            ``}` `            ``else` `{` `                ``// Use the number``                ``arr[i]--;``                ``calculate(arr, ans + i);` `                ``// Backtracking Step``                ``arr[i]++;``            ``}``        ``}``    ``}` `    ``// Function to find the all possible``    ``// permutations``    ``static` `void` `generatePermutation(``int` `n)``    ``{``        ``// Stores the frequency of digits``        ``int``[] temp = ``new` `int``;` `        ``// Iterate over the number``        ``while` `(n != 0) {``            ``int` `rem = n % 10;``            ``temp[rem]++;``            ``n = n / 10;``        ``}` `        ``// Function Call``        ``calculate(temp, ``""``);` `        ``// Print the result``        ``Console.WriteLine(H.Count);``      ``foreach``(``var` `val ``in` `H){``        ``Console.Write(val+``" "``);``      ``}``    ``}``    ``static` `public` `void` `Main (){` `      ``int` `N = 614;``      ``generatePermutation(N);``    ``}``}` `// This code is contributed by maddler.`

## Javascript

 ``

Output:

```4
[16, 64, 1, 4]```

Time Complexity: O(N*9N)
Auxiliary Space: O(1)

Efficient Approach: The idea is to generate all powers of two initially and store them in an appropriate data structure(“set OF CPP” in this case)  and check if a power of two exits In the string

• The difficulty here is to check if power of two exits in string.
• a naive approach to check if power of two exits in string is by generating all possible permutations of strings and verifying if that string is or string has a power of 2 this approach is not recommended as time complexity is around O(n!)
• An efficient approach is to use a count array which stores the count of decimal digits and verifying if the count of each decimal digit of a power of 2 is less than or equal to count of decimal digits present in string.

## C++14

 `#include``using` `namespace` `std;` `void` `calculatePower(string s,``int` `n,set<``long` `long``>&ans)``{``    ``// cnt_s is stores the count of each decimal digits of string s``    ``int` `cnt_s={0};``    ``// Here we calculate the count of each decimal digit of string s``    ``for``(``int` `i=0;i=cnt_[a])``    ``long` `val=2,one=1;``    ``long` `maxval=(one<<62);``    ``// maxval has max power of 2 in range of long``    ``// in this loop we generate powers of 2``    ``while``(val<=maxval&&val>0)``    ``{``        ``long` `temp=val;``        ``int` `cnt_a={0};``        ``// cnt_a has count of decimal digits in kth power of 2``        ``while``(temp)``        ``{``            ``long` `remainder=(temp%10);``            ``cnt_a[remainder]++;``            ``temp/=10;``        ``}``        ``// checking if a power of 2 present in string s``        ``bool` `fl=``true``;``        ``for``(``int` `i=0;i<10;i++)``        ``{``            ``if``(cnt_a[i]>cnt_s[i])``            ``{``                ``fl=``false``;``                ``break``;``            ``}``        ``}``        ``// if the power of 2 present in s we add it to set``        ``if``(fl)``        ``{``            ``ans.insert(val);``        ``}``        ``val*=2;``    ``}``}``int` `main()``{``     ``string s=``"614"``;``      ``int` `n=s.length();``      ` `    ``// set-ans has all possible powers of 2 that are present in string``    ``set<``long` `long``>ans;``      ``calculatePower(s,n,ans);``    ``cout<<``"THE TOTAL POSSIBLE COMBINATIONS THAT ARE POWER OF 2 ARE:  "``<

## C

 `#include``#include` `void` `calculatePower(``char` `s[],``int` `n)``{``    ``// cnt_s is stores the count of each decimal digits of string s``    ``int` `cnt_s={0};``    ``// Here we calculate the count of each decimal digit of string s``    ``for``(``int` `i=0;i=cnt_[a])``    ``long` `val=2,one=1;``    ``long` `maxval=(one<<62);``    ``// maxval has max power of 2 in range of long``    ``// in this loop we generate power of 2``    ``while``(val<=maxval&&val>0)``    ``{``        ``long` `temp=val;``        ``int` `cnt_a={0};``        ``// cnt_a has count of decimal digits in kth power of 2``        ``while``(temp)``        ``{``            ``long` `remainder=(temp%10);``            ``cnt_a[remainder]++;``            ``temp/=10;``        ``}``        ``// checking if a power of 2 present in string s``        ``int` `fl=1;``        ``for``(``int` `i=0;i<10;i++)``        ``{``            ``if``(cnt_a[i]>cnt_s[i])``            ``{``                ``fl=0;``                ``break``;``            ``}``        ``}``        ``if``(fl)``        ``{``            ``printf``(``"%ld  is present in string\n"``,val);``        ``}``        ``val*=2;``    ``}``}``int` `main()``{``    ``char` `s[]=``"614"``;``    ``int` `n=``strlen``(s);``      ``calculatePower(s,n);``}`

## Java

 `import` `java.util.*;``public` `class` `Main``{``    ``public` `static` `void` `calculatePower(String s,``int` `n)``    ``{``        ``ArrayList ans=``new` `ArrayList();``        ``// cnt_s is stores the count of each decimal digits of string s``        ``int` `cnt_s[]=``new` `int``[``10``];``        ``// Here we calculate the count of each decimal digit of string s``        ``for``(``int` `i=``0``;i=cnt_[a])``        ``long` `value=``2``,one=``1``;``        ``long` `maxvalue=(one<<``62``);``        ``// maxval has max power of 2 in range of long``        ``// in this loop we generate powers of 2``        ``while``(value<=maxvalue && value>=``0``)``        ``{``            ``long` `temp=value;``            ``int` `cnt_a[]=``new` `int``[``10``];``            ``// cnt_a has count of decimal digits in kth power of 2``            ``while``(temp>``0``)``            ``{``                ``long` `remainder=(temp%``10``);``                ``cnt_a[(``int``)remainder]++;``                ``temp/=``10``;``            ``}``            ``// checking if a power of 2 present in string s``            ``boolean` `fl=``true``;``            ``for``(``int` `i=``0``;i<``10``;i++)``            ``{``                ``if``(cnt_a[i]>cnt_s[i])``                ``{``                    ``fl=``false``;``                    ``break``;``                ``}``            ``}``            ``// if the power of 2 present in s we add it to ans``            ``if``(fl)``            ``{``                ``ans.add(value);``            ``}``            ``value*=``2``;``        ``}``        ``System.out.println(``"THE TOTAL POSSIBLE COMBINATIONS THAT ARE POWER OF 2 ARE: "``+ans.size());``        ``for``(Long i:ans)``        ``{``            ``System.out.println(i);``        ``}``    ``}``    ``public` `static` `void` `main(String[] args) {``        ``String s=``"614"``;``        ``int` `n=s.length();``        ``calculatePower(s,n);``    ``}``}`

## Python3

 `def` `calculatePower(s,n):``    ``# cnt_s is stores the count of each decimal digits of string s``    ``cnt_s``=``[``0``]``*``10``    ``# Here we calculate the count of each decimal digit of string s``    ``for` `i ``in` `s:``        ``cnt_s[``int``(i)]``+``=``1``    ``# our main logic is to generate powers of 2 and store the count of decimal digit of powers of 2 in  cnt_a i.e we check for every i in range(0,10): if(cnt_s[i]>=cnt_[a])``    ` `    ``one``=``1``    ``value``=``2``    ``maxvalue``=``(one<<``62``)``    ``ans``=``[]``    ``# maxval has max power of 2 in range of long in this loop we generate powers of 2``    ``while``(value<``=``maxvalue):``        ``# cnt_a has count of decimal digits in kth power of 2``        ``cnt_a``=``[``0``]``*``10``        ``fl``=``True``        ``temp``=``value``        ``while``(temp>``0``):``            ``remainder``=``temp``%``10``            ``cnt_a[remainder]``+``=``1``            ``temp``=``int``(temp``/``10``)``        ``# checking if a power of 2 present in string s``        ``for` `i ``in` `range``(``0``,``10``):``            ``if``(cnt_a[i]>cnt_s[i]):``                ``fl``=``False``                ``break``        ``# if the power of 2 present in s we add it to ans``        ``if``(fl):``            ``ans.append(value)``        ``value``*``=``2``    ``print``(``"THE TOTAL POSSIBLE COMBINATIONS THAT ARE POWER OF 2 ARE: "``,``len``(ans))``    ``for` `i ``in` `ans:``        ``print``(i)` `s``=``"614"``n``=``len``(s)``calculatePower(s,n)`

## C#

 `using` `System;``using` `System.Collections.Generic;``public` `class` `GFG {``  ``public` `static` `void` `calculatePower(``string` `s, ``int` `n)``  ``{``    ``List<``long``> ans = ``new` `List<``long``>();` `    ``// cnt_s is stores the count of each decimal digits``    ``// of string s``    ``int``[] cnt_s = ``new` `int``;` `    ``// Here we calculate the count of each decimal digit``    ``// of string s``    ``for` `(``int` `i = 0; i < n; i++) {``      ``cnt_s[s[i] - ``'0'``]++;``    ``}` `    ``// our main logic is to generate powers of 2 and``    ``// store the count of decimal digit of powers of 2``    ``// in cnt_a i.e we check for every i in range(0,10):``    ``// if(cnt_s[i]>=cnt_[a])``    ``long` `value = 2, one = 1;``    ``long` `maxvalue = (one << 62);` `    ``// maxval has max power of 2 in range of long``    ``// in this loop we generate powers of 2``    ``while` `(value <= maxvalue && value >= 0) {``      ``long` `temp = value;``      ``int``[] cnt_a = ``new` `int``;` `      ``// cnt_a has count of decimal digits in kth``      ``// power of 2``      ``while` `(temp > 0) {``        ``long` `remainder = (temp % 10);``        ``cnt_a[(``int``)remainder]++;``        ``temp /= 10;``      ``}` `      ``// checking if a power of 2 present in string s``      ``bool` `fl = ``true``;``      ``for` `(``int` `i = 0; i < 10; i++) {``        ``if` `(cnt_a[i] > cnt_s[i]) {``          ``fl = ``false``;``          ``break``;``        ``}``      ``}` `      ``// if the power of 2 present in s we add it to``      ``// ans``      ``if` `(fl) {``        ``ans.Add(value);``      ``}``      ``value *= 2;``    ``}``    ``Console.WriteLine(``      ``"THE TOTAL POSSIBLE COMBINATIONS THAT ARE POWER OF 2 ARE: "``      ``+ ans.Count);``    ``foreach``(``long` `i ``in` `ans) { Console.WriteLine(i); }``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``string` `s = ``"614"``;``    ``int` `n = s.Length;``    ``calculatePower(s, n);``  ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``

TIME COMPLEXITY: O(log(2^62) * N) where N is length of string and log(2^62) because 2^62 is max valid power in range of Long
AUXILIARY SPACE:O(10+10)

My Personal Notes arrow_drop_up