Related Articles

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

• Difficulty Level : Medium
• Last Updated : 10 May, 2021

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`

## Javascript

 ``
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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up