# Find Binary permutations of given size not present in the Array

• Difficulty Level : Medium
• Last Updated : 20 Sep, 2021

Given a positive integer N and an array arr[] of size K consisting of binary string where each string is of size N, the task is to find all the binary strings of size N that are not present in the array arr[].

Examples:

Input: N = 3, arr[] = {“101”, “111”, “001”, “010”, “011”, “100”, “110”}
Output: 000
Explanation: Only 000 is absent in the given array.

Input: N = 2, arr[] = {“00”, “01”}
Output: 10 11

Approach: The given problem can be solved by finding all binary strings of size N using Backtracking and then print those strings that are not present in the array arr[]. Follow the steps below to solve the problem:

• Initialize an unordered_set of strings S that stores all the strings in the array arr[].
• Initialize a variable, say total and set it as the power of 2N where N is the size of the string.
• Iterate over the range [0, total) using the variable i and perform the following steps:
• Initialize an empty string variable num as “”.
• Iterate over the range [N – 1, 0] using the variable j and if the value of the Bitwise AND of i and 2j is true, then push the character 1 into the string num. Otherwise, push the character 0.
• If num is not present in the set S then print the string num as the one of the resultant string.
• After completing the above steps, if all the possible binary strings are present in the array then print “-1”.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find a Binary String of` `// same length other than the Strings` `// present in the array` `void` `findMissingBinaryString(vector& nums, ``int` `N)` `{` `    ``unordered_set s;` `    ``int` `counter = 0;`   `    ``// Map all the strings present in` `    ``// the array` `    ``for` `(string str : nums) {` `        ``s.insert(str);` `    ``}`   `    ``int` `total = (``int``)``pow``(2, N);` `    ``string ans = ``""``;`   `    ``// Find all the substring that` `    ``// can be made` `    ``for` `(``int` `i = 0; i < total; i++) {` `        ``string num = ``""``;` `        ``for` `(``int` `j = N - 1; j >= 0; j--) {` `            ``if` `(i & (1 << j)) {` `                ``num += ``'1'``;` `            ``}` `            ``else` `{` `                ``num += ``'0'``;` `            ``}` `        ``}`   `        ``// If num already exists then` `        ``// increase counter` `        ``if` `(s.find(num) != s.end()) {` `            ``continue``;` `            ``counter++;` `        ``}`   `        ``// If not found print` `        ``else` `{` `            ``cout << num << ``", "``;` `        ``}` `    ``}`   `    ``// If all the substrings are present` `    ``// then print -1` `    ``if` `(counter == total) {` `        ``cout << ``"-1"``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 3;` `    ``vector arr` `        ``= { ``"101"``, ``"111"``, ``"001"``, ``"011"``, ``"100"``, ``"110"` `};`   `    ``findMissingBinaryString(arr, N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to find a Binary String of` `// same length other than the Strings` `// present in the array` `static` `void` `findMissingBinaryString(String[] nums, ``int` `N)` `{` `    ``HashSet s = ``new` `HashSet();` `    ``int` `counter = ``0``;`   `    ``// Map all the Strings present in` `    ``// the array` `    ``for` `(String str : nums) {` `        ``s.add(str);` `    ``}`   `    ``int` `total = (``int``)Math.pow(``2``, N);` `    ``String ans = ``""``;`   `    ``// Find all the subString that` `    ``// can be made` `    ``for` `(``int` `i = ``0``; i < total; i++) {` `        ``String num = ``""``;` `        ``for` `(``int` `j = N - ``1``; j >= ``0``; j--) {` `            ``if` `((i & (``1` `<< j))>``0``) {` `                ``num += ``'1'``;` `            ``}` `            ``else` `{` `                ``num += ``'0'``;` `            ``}` `        ``}`   `        ``// If num already exists then` `        ``// increase counter` `        ``if` `(s.contains(num)) {` `            `  `            ``counter++;` `            ``continue``;` `        ``}`   `        ``// If not found print` `        ``else` `{` `            ``System.out.print(num+ ``", "``);` `        ``}` `    ``}`   `    ``// If all the subStrings are present` `    ``// then print -1` `    ``if` `(counter == total) {` `        ``System.out.print(``"-1"``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``3``;` `    ``String []arr` `        ``= { ``"101"``, ``"111"``, ``"001"``, ``"011"``, ``"100"``, ``"110"` `};`   `    ``findMissingBinaryString(arr, N);`   `}` `}`   `// This code is contributed by Princi Singh`

## Python3

 `# Python 3 program for the above approach` `from` `math ``import` `pow`   `# Function to find a Binary String of` `# same length other than the Strings` `# present in the array` `def` `findMissingBinaryString(nums, N):` `    ``s ``=` `set``()` `    ``counter ``=` `0`   `    ``# Map all the strings present in` `    ``# the array` `    ``for` `x ``in` `nums:` `        ``s.add(x)`   `    ``total ``=` `int``(``pow``(``2``, N))` `    ``ans ``=` `""`   `    ``# Find all the substring that` `    ``# can be made` `    ``for` `i ``in` `range``(total):` `        ``num ``=` `""` `        ``j ``=` `N ``-` `1` `        ``while``(j >``=` `0``):` `            ``if` `(i & (``1` `<< j)):` `                ``num ``+``=` `'1'` `            ``else``:` `                ``num ``+``=` `'0'` `            ``j ``-``=` `1`   `        ``# If num already exists then` `        ``# increase counter` `        ``if` `(num ``in` `s):` `            ``continue` `            ``counter ``+``=` `1`   `        ``# If not found print` `        ``else``:` `            ``print``(num,end ``=` `", "``)`   `    ``# If all the substrings are present` `    ``# then print -1` `    ``if` `(counter ``=``=` `total):` `        ``print``(``"-1"``)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `3` `    ``arr ``=` `[``"101"``, ``"111"``, ``"001"``, ``"011"``, ``"100"``, ``"110"``]`   `    ``findMissingBinaryString(arr, N)` `    `  `    ``# This code is contributed by SURENDRA_GANGWAR.`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG {`   `    ``// Function to find a Binary String of` `    ``// same length other than the Strings` `    ``// present in the array` `    ``static` `void` `findMissingBinaryString(``string``[] nums,` `                                        ``int` `N)` `    ``{` `        ``HashSet<``string``> s = ``new` `HashSet<``string``>();` `        ``int` `counter = 0;`   `        ``// Map all the Strings present in` `        ``// the array` `        ``foreach``(``string` `str ``in` `nums) { s.Add(str); }`   `        ``int` `total = (``int``)Math.Pow(2, N);` `        ``// string ans = "";`   `        ``// Find all the subString that` `        ``// can be made` `        ``for` `(``int` `i = 0; i < total; i++) {` `            ``string` `num = ``""``;` `            ``for` `(``int` `j = N - 1; j >= 0; j--) {` `                ``if` `((i & (1 << j)) > 0) {` `                    ``num += ``'1'``;` `                ``}` `                ``else` `{` `                    ``num += ``'0'``;` `                ``}` `            ``}`   `            ``// If num already exists then` `            ``// increase counter` `            ``if` `(s.Contains(num)) {`   `                ``counter++;` `                ``continue``;` `            ``}`   `            ``// If not found print` `            ``else` `{` `                ``Console.Write(num + ``", "``);` `            ``}` `        ``}`   `        ``// If all the subStrings are present` `        ``// then print -1` `        ``if` `(counter == total) {` `            ``Console.Write(``"-1"``);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``int` `N = 3;` `        ``string``[] arr` `            ``= { ``"101"``, ``"111"``, ``"001"``, ``"011"``, ``"100"``, ``"110"` `};`   `        ``findMissingBinaryString(arr, N);` `    ``}` `}`   `// This code is contributed by ukasp.`

## Javascript

 ``

Output:

`000, 010,`

Time Complexity: O(N*2N)
Auxiliary Space: O(K), where K is the size of the array

My Personal Notes arrow_drop_up
Recommended Articles
Page :