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
Recommended: Please try your approach on {IDE} first, before moving on to the solution.
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-1 ‘1‘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 – 1 ‘1‘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 <bits/stdc++.h>
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.
#combinatorial #greedy #mathematical #strings #permutation and combination
