# Check if binary representations of 0 to N are present as substrings in given binary string

• Last Updated : 18 Jun, 2022

Give binary string str and an integer N, the task is to check if the substrings of the string contain all binary representations of non-negative integers less than or equal to the given integer N.

Examples:

Input: str = “0110″, N = 3
Output: True
Explanation:
Since substrings “0″, “1″, “10″, and “11″ can be formed from given string. Hence all binary representations of 0 to 3 are present as substrings in given binary string.

Input: str = “0110”, N = 4
Output: False
Explanation:
Since substrings “0″, “1″, “10″, and “11″ can be formed from given string, but not “100”. Hence the answer is False

Approach:
The above problem can be solved using BitSet and HashMap. Follow the steps given below to solve the problem

• Initialize a map[] to mark the strings and take a bit-set variable ans to convert the number from decimal to binary.
• Take one more variable count as zero.
• run the loop from N to 1 using the variable i and check the corresponding numbers are marked in a map or not.
• if number i is not marked in a map[] then convert the current number into binary using the bit-set variable ans.
• then check if converted binary string is substring of the given string or not.
• if it is not a substring then
• run while loop unless i is not marked and binary number becomes zero
• mark the i in a map
• increment the count
• do the right shift of converted number. This is done because if any string x is converted into binary (say 111001) and this substring is already marked in map, then 11100 will already be marked automatically.
This is based on the fact that if i exists, i>>1 also exists.
• Finally check if count ? N + 1, then print True
Else print False

Below is the implementation of above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to convert decimal to binary``// representation``string decimalToBinary(``int` `N)``{` `    ``string ans = ``""``;` `    ``// Iterate over all bits of N``    ``while` `(N > 0) {` `        ``// If bit is 1``        ``if` `(N & 1) {``            ``ans = ``'1'` `+ ans;``        ``}``        ``else` `{``            ``ans = ``'0'` `+ ans;``        ``}` `        ``N /= 2;``    ``}` `    ``// Return binary representation``    ``return` `ans;``}` `// Function to check if binary conversion``// of numbers from N to 1 exists in the``// string as a substring or not``string checkBinaryString(string& str, ``int` `N)``{` `    ``// To store the count of number``    ``// exists as a substring``    ``int` `map[N + 10], cnt = 0;` `    ``memset``(map, 0, ``sizeof``(map));` `    ``// Traverse from N to 1``    ``for` `(``int` `i = N; i > 0; i--) {` `        ``// If current number is not``        ``// present in map``        ``if` `(!map[i]) {` `            ``// Store current number``            ``int` `t = i;` `            ``// Find binary of t``            ``string s = decimalToBinary(t);` `            ``// If the string s is a``            ``// substring of str``            ``if` `(str.find(s) != str.npos) {` `                ``while` `(t && !map[t]) {` `                    ``// Mark t as true``                    ``map[t] = 1;` `                    ``// Increment the count``                    ``cnt++;` `                    ``// Update for t/2``                    ``t >>= 1;``                ``}``            ``}``        ``}``    ``}` `    ``// Special judgement '0'``    ``for` `(``int` `i = 0; i < str.length(); i++) {``        ``if` `(str[i] == ``'0'``) {``            ``cnt++;``            ``break``;``        ``}``    ``}``    ``// If the count is N+1, return "yes"``    ``if` `(cnt == N + 1)``        ``return` `"True"``;``    ``else``        ``return` `"False"``;``}` `// Driver Code``int` `main()``{``    ``// Given String``    ``string str = ``"0110"``;` `    ``// Given Number``    ``int` `N = 3;` `    ``// Function Call``    ``cout << checkBinaryString(str, N);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to convert decimal to binary``// representation``static` `String decimalToBinary(``int` `N)``{``    ``String ans = ``""``;` `    ``// Iterate over all bits of N``    ``while` `(N > ``0``)``    ``{``        ` `        ``// If bit is 1``        ``if` `(N % ``2` `== ``1``)``        ``{``            ``ans = ``'1'` `+ ans;``        ``}``        ``else``        ``{``            ``ans = ``'0'` `+ ans;``        ``}``        ``N /= ``2``;``    ``}` `    ``// Return binary representation``    ``return` `ans;``}` `// Function to check if binary conversion``// of numbers from N to 1 exists in the``// String as a subString or not``static` `String checkBinaryString(String str, ``int` `N)``{``    ` `    ``// To store the count of number``    ``// exists as a subString``    ``int` `[]map = ``new` `int``[N + ``10``];``    ``int` `cnt = ``0``;` `    ``// Traverse from N to 1``    ``for``(``int` `i = N; i > ``0``; i--)``    ``{` `        ``// If current number is not``        ``// present in map``        ``if` `(map[i] == ``0``)``        ``{``            ` `            ``// Store current number``            ``int` `t = i;` `            ``// Find binary of t``            ``String s = decimalToBinary(t);` `            ``// If the String s is a``            ``// subString of str``            ``if` `(str.contains(s))``            ``{``                ``while` `(t > ``0` `&& map[t] == ``0``)``                ``{``                    ` `                    ``// Mark t as true``                    ``map[t] = ``1``;` `                    ``// Increment the count``                    ``cnt++;` `                    ``// Update for t/2``                    ``t >>= ``1``;``                ``}``            ``}``        ``}``    ``}` `    ``// Special judgement '0'``    ``for``(``int` `i = ``0``; i < str.length(); i++)``    ``{``        ``if` `(str.charAt(i) == ``'0'``)``        ``{``            ``cnt++;``            ``break``;``        ``}``    ``}``    ` `    ``// If the count is N+1, return "yes"``    ``if` `(cnt == N + ``1``)``        ``return` `"True"``;``    ``else``        ``return` `"False"``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Given String``    ``String str = ``"0110"``;` `    ``// Given number``    ``int` `N = ``3``;` `    ``// Function call``    ``System.out.print(checkBinaryString(str, N));``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 implementation of``# the above approach` `# Function to convert decimal to``# binary representation``def` `decimalToBinary(N):` `    ``ans ``=` `""` `    ``# Iterate over all bits of N``    ``while``(N > ``0``):` `        ``# If bit is 1``        ``if``(N & ``1``):``            ``ans ``=` `'1'` `+` `ans``        ``else``:``            ``ans ``=` `'0'` `+` `ans` `        ``N ``/``/``=` `2` `    ``# Return binary representation``    ``return` `ans` `# Function to check if binary conversion``# of numbers from N to 1 exists in the``# string as a substring or not``def` `checkBinaryString(``str``, N):` `    ``# To store the count of number``    ``# exists as a substring``    ``map` `=` `[``0``] ``*` `(N ``+` `10``)``    ``cnt ``=` `0` `    ``# Traverse from N to 1``    ``for` `i ``in` `range``(N, ``-``1``, ``-``1``):` `        ``# If current number is not``        ``# present in map``        ``if``(``not` `map``[i]):` `            ``# Store current number``            ``t ``=` `i` `            ``# Find binary of t``            ``s ``=` `decimalToBinary(t)` `            ``# If the string s is a``            ``# substring of str``            ``if``(s ``in` `str``):``                ``while``(t ``and` `not` `map``[t]):``                    ` `                    ``# Mark t as true``                    ``map``[t] ``=` `1` `                    ``# Increment the count``                    ``cnt ``+``=` `1` `                    ``# Update for t/2``                    ``t >>``=` `1` `    ``# Special judgement '0'``    ``for` `i ``in` `range``(``len``(``str``)):``        ``if``(``str``[i] ``=``=` `'0'``):``            ``cnt ``+``=` `1``            ``break` `    ``# If the count is N+1, return "yes"``    ``if``(cnt ``=``=` `N ``+` `1``):``        ``return` `"True"``    ``else``:``        ``return` `"False"` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:` `    ``# Given String``    ``str` `=` `"0110"` `    ``# Given Number``    ``N ``=` `3` `    ``# Function Call``    ``print``(checkBinaryString(``str``, N))` `# This code is contributed by Shivam Singh`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `// Function to convert decimal to binary``// representation``static` `String decimalToBinary(``int` `N)``{``    ``String ans = ``""``;` `    ``// Iterate over all bits of N``    ``while` `(N > 0)``    ``{``        ` `        ``// If bit is 1``        ``if` `(N % 2 == 1)``        ``{``            ``ans = ``'1'` `+ ans;``        ``}``        ``else``        ``{``            ``ans = ``'0'` `+ ans;``        ``}``        ``N /= 2;``    ``}` `    ``// Return binary representation``    ``return` `ans;``}` `// Function to check if binary conversion``// of numbers from N to 1 exists in the``// String as a subString or not``static` `String checkBinaryString(String str, ``int` `N)``{``    ` `    ``// To store the count of number``    ``// exists as a subString``    ``int` `[]map = ``new` `int``[N + 10];``    ``int` `cnt = 0;` `    ``// Traverse from N to 1``    ``for``(``int` `i = N; i > 0; i--)``    ``{` `        ``// If current number is not``        ``// present in map``        ``if` `(map[i] == 0)``        ``{``            ` `            ``// Store current number``            ``int` `t = i;` `            ``// Find binary of t``            ``String s = decimalToBinary(t);` `            ``// If the String s is a``            ``// subString of str``            ``if` `(str.Contains(s))``            ``{``                ``while` `(t > 0 && map[t] == 0)``                ``{``                    ` `                    ``// Mark t as true``                    ``map[t] = 1;` `                    ``// Increment the count``                    ``cnt++;` `                    ``// Update for t/2``                    ``t >>= 1;``                ``}``            ``}``        ``}``    ``}` `    ``// Special judgement '0'``    ``for``(``int` `i = 0; i < str.Length; i++)``    ``{``        ``if` `(str[i] == ``'0'``)``        ``{``            ``cnt++;``            ``break``;``        ``}``    ``}``    ` `    ``// If the count is N+1, return "yes"``    ``if` `(cnt == N + 1)``        ``return` `"True"``;``    ``else``        ``return` `"False"``;``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ` `    ``// Given String``    ``String str = ``"0110"``;` `    ``// Given number``    ``int` `N = 3;` `    ``// Function call``    ``Console.Write(checkBinaryString(str, N));``}``}` `// This code is contributed by PrinciRaj1992`

## Javascript

 ``

Output:

`True`

Time Complexity: O(N logN)
Auxiliary Space: O(N), as extra space of size N is used to make an array

My Personal Notes arrow_drop_up