GFG App
Open App
Browser
Continue

# Check if N sized String with given number of 00, 01, 10, 11 Substrings exists

Given an integer N and four values a, b, c, d (where a ≥ 0, b ≥ 0, c ≥ 0, d ≥ 0), the task is to check if it is possible to create a binary string of length N such that:

• There are exactly a substrings of “00”
• There are exactly b substrings of “01”
• There are exactly c substrings of “10”
• There are exactly d substrings of “11”

Examples:

Input:  N = 11, a = 2, b = 3, c = 3, d = 2
Output : Yes
Explanation : In this string, exactly 2 numbers of 00, exactly 3 numbers 01, exactly 3 numbers of 10 and exactly 2 numbers of 11.

Input : N = 11, a = 0, b = 3, c = 3, d = 0
Output: No
Explanation : We can make a string with exactly 3 numbers of 01 and 3 numbers of 10, but string size will be 7, so can’t possible to make a perfect binary string with 11 length.

Input: N = 4, a = 1, b = 0, c = 0, d = 1
Output: No
Explanation : We can’t make a string because if 00 are there and 11 are there, it is must that 01 or 10 will be there in junction of 00 and 11

Observation:

We have to check the cases where string can’t be formed.

• Case 1: when number of  01 and 10 pairs are zero, then it can’t be possible to create a string if 00 and 11 pairs appears non-zero times. Because, these are required to form  a 01 or 10 in the junction of 00 and 11.
• Case 2: when b and c are the number of  01 and 10 pairs, then it is not possible to create a string if abs(b-c)>1.
• Case 3: If case 1 and case 2 are not happening and string is formed with exact pairs of 00, 11, 10, 01 and if the length of the string is not equal to n, then the string is not possible.

Approach: Follow the below approach to solve the problem:

• Check if 01 and 10 appear zero times and 00 and 11 appear non-zero times then it is not possible to create such binary string.
• Check if the absolute difference between numbers 01 and 10 is:
• Greater than 1, abs(b – c) > 1, then it is not possible to create a string.
• Equal to 1, calculate the length of the string, if it is equal to n, return true, else return false.
• Equal to 0, calculate the length of the string, if it is equal to n, return true, else return false.

Steps were to follow the above approach:

• Initialize a variable say, sum = 0 to calculate the length of the string.
• Check if b == 0 && c == 0 && d != 0 && a != 0, then it is not possible to create a perfect binary string, return false.
• Check if abs(b – c) > 1, then it is not possible to create a perfect binary string, return false.
• Check if abs(b – c) == 1, and calculate the length of the string, by updating the sum
• Add max(b, c) * 2 to sum
• Add ‘d’ to the sum
• Increment sum by 1.
• Check if sum != n, return false, else return true.
• Check if b == c, calculate the length of the string, and check if sum != n, return false, else return true.

Below is the implementation for the above approach:

## C++

 `// C++ code for the above approach` `#include ` `using` `namespace` `std;`   `// Function to check if it possible to` `// create the required binary string` `bool` `requiredString(``int` `n, ``int` `a, ``int` `b, ``int` `c, ``int` `d)` `{`   `    ``// Initialize a integer variable sum` `    ``// to calculate the length` `    ``// of the string` `    ``int` `sum = 0;`   `    ``// Check if 01 and 10 are appears zero` `    ``// times and 00 and 11 appears non-zero` `    ``// times then it is not possible to` `    ``// create a perfect binary string` `    ``if` `(b == 0 && c == 0 && d != 0 && a != 0) {` `        ``return` `false``;` `    ``}`   `    ``// If absolute difference between 01` `    ``// and 10 are greater than 1 then not` `    ``// possible to create a string.` `    ``else` `if` `(``abs``(b - c) > 1) {` `        ``return` `false``;` `    ``}`   `    ``// If absolute difference between 01` `    ``// and 10 are equal to 1 then check` `    ``// the length of the string, if the` `    ``// length is equal to n` `    ``else` `if` `(``abs``(b - c) == 1) {` `        ``sum += max(b, c) * 2;` `        ``sum += a;` `        ``sum += d;`   `        ``if` `(sum != n) {` `            ``return` `false``;` `        ``}` `    ``}`   `    ``// If absolute difference between 01` `    ``// and 10 are equal to 0 then check` `    ``// the length of the string, if the` `    ``// length is equal to n` `    ``else` `if` `(b == c) {` `        ``sum += max(b, c) * 2;` `        ``sum += a;` `        ``sum += d;` `        ``sum += 1;` `        ``if` `(sum != n) {` `            ``return` `false``;` `        ``}` `    ``}` `    ``return` `true``;` `}`   `// Driver Code` `int` `main()` `{`   `    ``// Given five integers` `    ``int` `n = 11, a = 2, b = 3, c = 3, d = 2;`   `    ``if` `(requiredString(n, a, b, c, d)) {` `        ``cout << ``"Yes"` `<< endl;` `    ``}` `    ``else` `{` `        ``cout << ``"No"` `<< endl;` `    ``}`   `    ``return` `0;` `}`

## Java

 `// Java code for the above approach` `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to check if it possible to` `    ``// create the required binary string` `    ``static` `boolean` `requiredString(``int` `n, ``int` `a, ``int` `b,` `                                  ``int` `c, ``int` `d)` `    ``{`   `        ``// Initialize a integer variable sum` `        ``// to calculate the length` `        ``// of the string` `        ``int` `sum = ``0``;`   `        ``// Check if 01 and 10 are appears zero` `        ``// times and 00 and 11 appears non-zero` `        ``// times then it is not possible to` `        ``// create a perfect binary string` `        ``if` `(b == ``0` `&& c == ``0` `&& d != ``0` `&& a != ``0``) {` `            ``return` `false``;` `        ``}`   `        ``// If absolute difference between 01` `        ``// and 10 are greater than 1 then not` `        ``// possible to create a string.` `        ``else` `if` `(Math.abs(b - c) > ``1``) {` `            ``return` `false``;` `        ``}`   `        ``// If absolute difference between 01` `        ``// and 10 are equal to 1 then check` `        ``// the length of the string, if the` `        ``// length is equal to n` `        ``else` `if` `(Math.abs(b - c) == ``1``) {` `            ``sum += Math.max(b, c) * ``2``;` `            ``sum += a;` `            ``sum += d;`   `            ``if` `(sum != n) {` `                ``return` `false``;` `            ``}` `        ``}`   `        ``// If absolute difference between 01` `        ``// and 10 are equal to 0 then check` `        ``// the length of the string, if the` `        ``// length is equal to n` `        ``else` `if` `(b == c) {` `            ``sum += Math.max(b, c) * ``2``;` `            ``sum += a;` `            ``sum += d;` `            ``sum += ``1``;` `            ``if` `(sum != n) {` `                ``return` `false``;` `            ``}` `        ``}` `        ``return` `true``;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``// Given five integers` `        ``int` `n = ``11``, a = ``2``, b = ``3``, c = ``3``, d = ``2``;`   `        ``if` `(requiredString(n, a, b, c, d)) {` `            ``System.out.println(``"Yes"``);` `        ``}` `        ``else` `{` `            ``System.out.println(``"No"``);` `        ``}` `    ``}` `}`   `// This code is contributed by prasad264`

## Python3

 `# Python code for the above approach`   `# Function to check if it possible to create the required binary string` `def` `requiredString(n, a, b, c, d):`   `    ``# Initialize a integer variable sum` `    ``# to calculate the length of the string` `    ``sum` `=` `0`   `    ``# Check if 01 and 10 are appears zero times and 00 and 11 appears non-zero times` `    ``# then it is not possible to create a perfect binary string` `    ``if` `b ``=``=` `0` `and` `c ``=``=` `0` `and` `d !``=` `0` `and` `a !``=` `0``:` `        ``return` `False`   `    ``# If absolute difference between 01 and 10 ` `    ``# are greater than 1 then not possible to create a string.` `    ``elif` `abs``(b ``-` `c) > ``1``:` `        ``return` `False`   `    ``# If absolute difference between 01 and 10 are ` `    ``# equal to 1 then check the length of the string,` `    ``# if the length is equal to n` `    ``elif` `abs``(b ``-` `c) ``=``=` `1``:` `        ``sum` `+``=` `max``(b, c) ``*` `2` `        ``sum` `+``=` `a` `        ``sum` `+``=` `d`   `        ``if` `sum` `!``=` `n:` `            ``return` `False` `    ``# If absolute difference between 01 and 10` `    ``# are equal to 0 then check the length of the string,` `    ``# if the length is equal to n` `    ``elif` `b ``=``=` `c:` `        ``sum` `+``=` `max``(b, c) ``*` `2` `        ``sum` `+``=` `a` `        ``sum` `+``=` `d` `        ``sum` `+``=` `1` `        ``if` `sum` `!``=` `n:` `            ``return` `False`   `    ``return` `True`     `# Driver code` `n ``=` `11` `a ``=` `2` `b ``=` `3` `c ``=` `3` `d ``=` `2`   `if` `requiredString(n, a, b, c, d):` `    ``print``(``"Yes"``)` `else``:` `    ``print``(``"No"``)` `# This code is contributed by rutikbhosale`

## C#

 `// C# code for the above approach` `using` `System;`   `class` `Program {` `    ``// Function to check if it possible to` `    ``// create the required binary string` `    ``static` `bool` `RequiredString(``int` `n, ``int` `a, ``int` `b, ``int` `c,` `                               ``int` `d)` `    ``{`   `        ``// Initialize a integer variable sum` `        ``// to calculate the length` `        ``// of the string` `        ``int` `sum = 0;`   `        ``// Check if 01 and 10 are appears zero` `        ``// times and 00 and 11 appears non-zero` `        ``// times then it is not possible to` `        ``// create a perfect binary string` `        ``if` `(b == 0 && c == 0 && d != 0 && a != 0) {` `            ``return` `false``;` `        ``}`   `        ``// If absolute difference between 01` `        ``// and 10 are greater than 1 then not` `        ``// possible to create a string.` `        ``else` `if` `(Math.Abs(b - c) > 1) {` `            ``return` `false``;` `        ``}`   `        ``// If absolute difference between 01` `        ``// and 10 are equal to 1 then check` `        ``// the length of the string, if the` `        ``// length is equal to n` `        ``else` `if` `(Math.Abs(b - c) == 1) {` `            ``sum += Math.Max(b, c) * 2;` `            ``sum += a;` `            ``sum += d;`   `            ``if` `(sum != n) {` `                ``return` `false``;` `            ``}` `        ``}`   `        ``// If absolute difference between 01` `        ``// and 10 are equal to 0 then check` `        ``// the length of the string, if the` `        ``// length is equal to n` `        ``else` `if` `(b == c) {` `            ``sum += Math.Max(b, c) * 2;` `            ``sum += a;` `            ``sum += d;` `            ``sum += 1;` `            ``if` `(sum != n) {` `                ``return` `false``;` `            ``}` `        ``}` `        ``return` `true``;` `    ``}`   `    ``// Driver Code` `    ``static` `void` `Main(``string``[] args)` `    ``{` `        ``// Given five integers` `        ``int` `n = 11, a = 2, b = 3, c = 3, d = 2;`   `        ``if` `(RequiredString(n, a, b, c, d)) {` `            ``Console.WriteLine(``"Yes"``);` `        ``}` `        ``else` `{` `            ``Console.WriteLine(``"No"``);` `        ``}` `    ``}` `}`

## Javascript

 `// Function to check if it is possible to create the required binary string` `function` `requiredString(n, a, b, c, d) {` `  ``let sum = 0;`   `  ``// Check if 01 and 10 are not appearing and 00 and 11 are appearing non-zero times, then it is not possible to create a perfect binary string` `  ``if` `(b === 0 && c === 0 && d !== 0 && a !== 0) {` `    ``return` `false``;` `  ``}`   `  ``// If absolute difference between 01 and 10 are greater than 1, then it is not possible to create a string` `  ``else` `if` `(Math.abs(b - c) > 1) {` `    ``return` `false``;` `  ``}`   `  ``// If absolute difference between 01 and 10 are equal to 1, then check the length of the string, if the length is equal to n` `  ``else` `if` `(Math.abs(b - c) === 1) {` `    ``sum += Math.max(b, c) * 2;` `    ``sum += a;` `    ``sum += d;`   `    ``if` `(sum !== n) {` `      ``return` `false``;` `    ``}` `  ``}`   `  ``// If absolute difference between 01 and 10 are equal to 0, then check the length of the string, if the length is equal to n` `  ``else` `if` `(b === c) {` `    ``sum += Math.max(b, c) * 2;` `    ``sum += a;` `    ``sum += d;` `    ``sum += 1;`   `    ``if` `(sum !== n) {` `      ``return` `false``;` `    ``}` `  ``}`   `  ``return` `true``;` `}`   `// Driver code` `const n = 11;` `const a = 2;` `const b = 3;` `const c = 3;` `const d = 2;`   `if` `(requiredString(n, a, b, c, d)) {` `  ``console.log(``"Yes"``);` `} ``else` `{` `  ``console.log(``"No"``);` `}`

Output

`Yes`

Time Complexity: O(1)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up