# Generate a Binary String without any consecutive 0’s and at most K consecutive 1’s

Given two integers N and M, the task is to construct a binary string with the following conditions :

• The Binary String consists of N 0’s and M 1’s
• The Binary String has at most K consecutive 1’s.
• The Binary String does not contain any adjacent 0’s.

If it is not possible to construct such a binary string, then print -1.

Examples:

Input: N = 5, M = 9, K = 2
Output: 01101101101101
Explanation:
The string “01101101101101” satisfies the following conditions:

• No consecutive 0’s are present.
• No more than K(= 2) consecutive 1’s are present.

Input: N = 4, M = 18, K = 4
Output: 1101111011110111101111

Approach:

To construct a binary string satisfying the given properties, observe the following:

• For no two ‘0‘s to be consecutive, there should be at least a ‘1‘ placed between them.
• Therefore, for N number of ‘0‘s, there should be at least N-11‘s present for a string of required type to be generated.
• Since no more than K consecutive ‘1‘s can be placed together, for N 0’s, there can be a maximum (N+1) * K ‘1‘s possible.
• Therefore, the number of ‘1‘s should lie within the range:

N – 1 ? M ? (N + 1) * K

• If the given values N and M do not satisfy the above condition, then print -1.
• Otherwise, follow the steps below to solve the problem:
• Append ‘0‘s to the final string.
• Insert ‘1‘ in between each pair of 0′s. Subtract N – 1 from M, as N – 11‘s have already been placed.
• For the remaining ‘1‘s, place min(K – 1, M)1‘s alongside each already placed ‘1‘s, to ensure that no more than K ‘1’s are placed together.
• For any remaining ‘1‘s, append them to the beginning and end of the final string.
• Finally, print the string generated.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement` `// the above approach` `#include ` `using` `namespace` `std;`   `// Function to construct the binary string` `string ConstructBinaryString(``int` `N, ``int` `M,` `                             ``int` `K)` `{` `    ``// Conditions when string construction` `    ``// is not possible` `    ``if` `(M < (N - 1) || M > K * (N + 1))` `        ``return` `"-1"``;`   `    ``string ans = ``""``;`   `    ``// Stores maximum 1's that` `    ``// can be placed in between` `    ``int` `l = min(K, M / (N - 1));` `    ``int` `temp = N;` `    ``while` `(temp--) {` `        ``// Place 0's` `        ``ans += ``'0'``;`   `        ``if` `(temp == 0)` `            ``break``;`   `        ``// Place 1's in between` `        ``for` `(``int` `i = 0; i < l; i++) {` `            ``ans += ``'1'``;` `        ``}` `    ``}`   `    ``// Count remaining M's` `    ``M -= (N - 1) * l;`   `    ``if` `(M == 0)` `        ``return` `ans;`   `    ``l = min(M, K);` `    ``// Place 1's at the end` `    ``for` `(``int` `i = 0; i < l; i++)` `        ``ans += ``'1'``;`   `    ``M -= l;` `    ``// Place 1's at the beginning` `    ``while` `(M > 0) {` `        ``ans = ``'1'` `+ ans;` `        ``M--;` `    ``}`   `    ``// Return the final string` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 5, M = 9, K = 2;`   `    ``cout << ConstructBinaryString(N, M, K);` `}`

## Java

 `// Java implementation of ` `// the above approach ` `class` `GFG{` `    `  `// Function to construct the binary string` `static` `String ConstructBinaryString(``int` `N, ``int` `M,` `                                    ``int` `K)` `{` `    `  `    ``// Conditions when string construction` `    ``// is not possible` `    ``if` `(M < (N - ``1``) || M > K * (N + ``1``))` `        ``return` `"-1"``;`   `    ``String ans = ``""``;`   `    ``// Stores maximum 1's that` `    ``// can be placed in between` `    ``int` `l = Math.min(K, M / (N - ``1``));` `    ``int` `temp = N;` `    `  `    ``while` `(temp != ``0``)` `    ``{` `        ``temp--;` `        `  `        ``// Place 0's` `        ``ans += ``'0'``;`   `        ``if` `(temp == ``0``)` `            ``break``;`   `        ``// Place 1's in between` `        ``for``(``int` `i = ``0``; i < l; i++) ` `        ``{` `            ``ans += ``'1'``;` `        ``}` `    ``}`   `    ``// Count remaining M's` `    ``M -= (N - ``1``) * l;`   `    ``if` `(M == ``0``)` `        ``return` `ans;`   `    ``l = Math.min(M, K);` `    `  `    ``// Place 1's at the end` `    ``for``(``int` `i = ``0``; i < l; i++)` `        ``ans += ``'1'``;`   `    ``M -= l;` `    `  `    ``// Place 1's at the beginning` `    ``while` `(M > ``0``) ` `    ``{` `        ``ans = ``'1'` `+ ans;` `        ``M--;` `    ``}`   `    ``// Return the final string` `    ``return` `ans;` `}`   `// Driver code    ` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``5``, M = ``9``, K = ``2``;` `    `  `    ``System.out.println(ConstructBinaryString(N, M, K));` `}` `}`   `// This code is contributed by rutvik_56`

## Python3

 `# Python3 implementation of` `# the above approach`   `# Function to construct the binary string` `def` `ConstructBinaryString(N, M, K):`   `    ``# Conditions when string construction` `    ``# is not possible` `    ``if``(M < (N ``-` `1``) ``or` `M > K ``*` `(N ``+` `1``)):` `        ``return` `'-1'`   `    ``ans ``=` `""`   `    ``# Stores maximum 1's that` `    ``# can be placed in between` `    ``l ``=` `min``(K, M ``/``/` `(N ``-` `1``))` `    ``temp ``=` `N` `    `  `    ``while``(temp):` `        ``temp ``-``=` `1`   `        ``# Place 0's` `        ``ans ``+``=` `'0'`   `        ``if``(temp ``=``=` `0``):` `            ``break`   `        ``# Place 1's in between` `        ``for` `i ``in` `range``(l):` `            ``ans ``+``=` `'1'`   `    ``# Count remaining M's` `    ``M ``-``=` `(N ``-` `1``) ``*` `l`   `    ``if``(M ``=``=` `0``):` `        ``return` `ans`   `    ``l ``=` `min``(M, K)` `    `  `    ``# Place 1's at the end` `    ``for` `i ``in` `range``(l):` `        ``ans ``+``=` `'1'`   `    ``M ``-``=` `l` `    `  `    ``# Place 1's at the beginning` `    ``while``(M > ``0``):` `        ``ans ``=` `'1'` `+` `ans` `        ``M ``-``=` `1`   `    ``# Return the final string` `    ``return` `ans`   `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``:`   `    ``N ``=` `5` `    ``M ``=` `9` `    ``K ``=` `2` `    `  `    ``print``(ConstructBinaryString(N, M , K))`   `# This code is contributed by Shivam Singh`

## C#

 `// C# implementation of ` `// the above approach ` `using` `System;` `class` `GFG{` `     `  `// Function to construct the binary string` `static` `String ConstructBinaryString(``int` `N, ``int` `M,` `                                    ``int` `K)` `{` `     `  `    ``// Conditions when string construction` `    ``// is not possible` `    ``if` `(M < (N - 1) || M > K * (N + 1))` `        ``return` `"-1"``;` ` `  `    ``string` `ans = ``""``;` ` `  `    ``// Stores maximum 1's that` `    ``// can be placed in between` `    ``int` `l = Math.Min(K, M / (N - 1));` `    ``int` `temp = N;` `     `  `    ``while` `(temp != 0)` `    ``{` `        ``temp--;` `         `  `        ``// Place 0's` `        ``ans += ``'0'``;` ` `  `        ``if` `(temp == 0)` `            ``break``;` ` `  `        ``// Place 1's in between` `        ``for``(``int` `i = 0; i < l; i++) ` `        ``{` `            ``ans += ``'1'``;` `        ``}` `    ``}` ` `  `    ``// Count remaining M's` `    ``M -= (N - 1) * l;` ` `  `    ``if` `(M == 0)` `        ``return` `ans;` ` `  `    ``l = Math.Min(M, K);` `     `  `    ``// Place 1's at the end` `    ``for``(``int` `i = 0; i < l; i++)` `        ``ans += ``'1'``;` ` `  `    ``M -= l;` `     `  `    ``// Place 1's at the beginning` `    ``while` `(M > 0) ` `    ``{` `        ``ans = ``'1'` `+ ans;` `        ``M--;` `    ``}` ` `  `    ``// Return the final string` `    ``return` `ans;` `}` ` `  `// Driver code    ` `public` `static` `void` `Main(``string``[] args)` `{` `    ``int` `N = 5, M = 9, K = 2;` `     `  `    ``Console.Write(ConstructBinaryString(N, M, K));` `}` `}` ` `  `// This code is contributed by Ritik Bansal`

Output:

```01101101101101

```

Time Complexity: O(N+M)
Auxiliary Space: O(N+M)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.