Find any permutation of Binary String of given size not present in Array

In this problem, we need to find all missing binary strings of length N from the array. We can solve the problem by finding all permutations of a binary string of length N and checking which permutations are absent in the array. Here, we will see iterative and recursive approaches to solve the problem.

Problem statement – We have given an array arr[] of different lengths containing the binary strings of length N. We need to find all the missing binary strings of length N from the array.

Sample examples

Input – arr = {"111", "001", "100", "110"}, N = 3

Output – [000, 010, 011, 101]

Explanation – There are 8 binary strings of length 3 as 23 = 8. So, it prints the missing 4 binary strings of length 3.

Input – str = {‘00’, ‘10’, ‘11’}, N = 2

Output – [‘01’]

Explanation – As ‘01’ is missing from the array, it prints in the output.

Approach 1

Here, we will use the iterative approach to find all possible binary strings of length N. After that, we will check whether the string is present in the array. If not, we print the string.

Algorithm

• Define the set and use the insert() method to add all strings of the array into the set.

• Initialize the total variable with the 2N, which is the total number of strings of length N

• Define the ‘cnt’ variable and initialize with zero to store the total number of missing combinations.

• Use the loop to make the ‘total’ number of iterations to find all binary strings of length N.

• In the loop, initialize the ‘num’ string variable with an empty string.

• Use the nested loop making total N iterations and starting iterations from last to create a string of length N.

• Use the find() method to check whether the set contains the current string. If yes, increment the value of ‘cnt’ by 1.

• If the string is not present in the map, print it to show in the output

• If the value of the ‘cnt’ is equal to the total, it means all strings of length N are present in the array and print “-1”.

Example

#include <bits/stdc++.h>
using namespace std;
// function to print missing combinations of a binary string of length N in an array
void printMissingCombinations(vector<string> &arr, int N) {
   unordered_set<string> set;
   // insert all the strings in the set
   for (string temp : arr) {
      set.insert(temp);
   }
   // get total combinations for the string of length N
   int total = (int)pow(2, N);
   // To store combinations that are present in an array
   int cnt = 0;
   // find all the combinations
   for (int p = 0; p < total; p++) {
      // Initialize empty binary string
      string bin = "";
      for (int q = N - 1; q >= 0; q--) {
          // If the qth bit is set, append '1'; append '0'.
          if (p & (1 << q)) {
              bin += '1';
          } else {
              bin += '0';
          }
      }
      // If the combination is present in an array, increment cnt
      if (set.find(bin) != set.end()) {
          cnt++;
          continue;
      } else {
          cout << bin << ", ";
      }
   }
   // If all combinations are present in an array, print -1
   if (cnt == total) {
      cout << "-1";
   }
}
int main() {
   int N = 3;
   vector<string> arr = {"111", "001", "100", "110"};
   printMissingCombinations(arr, N);
   return 0;
}

Output

000, 010, 011, 101, 

Time complexity – O(N*2N), where O(N) to check if a string exists in the array, and O(2N) is for finding all possible permutations.

Space complexity – O(N) as we use the set to store strings.

Approach 2

In this approach, we demonstrated to use the recursive approach to find all possible binary strings of length N.

Algorithm

• Define the set and insert all array values in the set.

• Call the generateCombinations() function to generate all combinations of the binary string

• Define the base case in the generateCombinations() function. If the index is equal to N, push the currentCombination to the list.

• Recursively call the generateCombinations() function after appending the ‘0’ or ‘1’ to the currentCombination.

• After getting all combinations, check which are present and which are not in the array. Also, print the missing combinations to show in the output.

Example

#include <bits/stdc++.h>
using namespace std;
// Function to generate all possible combinations of binary strings
void generateCombinations(int index, int N, string currentCombination, vector<string> &combinations) {
   // Base case: if we have reached the desired length N, add the combination to the vector
   if (index == N) {
      combinations.push_back(currentCombination);
      return;
   }
   // Recursively generate combinations by trying both 0 and 1 at the current index
   generateCombinations(index + 1, N, currentCombination + "0", combinations);
   generateCombinations(index + 1, N, currentCombination + "1", combinations);
}
// function to print missing combinations of a binary string of length N in an array
void printMissingCombinations(vector<string> &arr, int N) {    
   unordered_set<string> set;
   // insert all the strings in the set
   for (string str : arr) {
      set.insert(str);
   }
   // generating all combinations of binary strings of length N
   vector<string> combinations;
   generateCombinations(0, N, "", combinations);
   // Traverse all the combinations and check if it is present in the set or not
   for (string str : combinations) {
      // If the combination is not present in the set, print it
      if (set.find(str) == set.end()) {
          cout << str << endl;
      }
   }

   return;
}
int main(){
   int N = 3;
   vector<string> arr = {"111", "001", "100", "110"};
   printMissingCombinations(arr, N);
   return 0;
}

Output

000
010
011
101

Time complexity – O(N*2N)

Space complexity – O(2N) as we store all combinations in the array.

Both approaches use the same logic to solve the problem. The first approach uses the iterative technique to find all combinations of the binary strings of length N which is faster than the recursive technique used in the second approach. Furthermore, the second approach consumes more space than the first.