Given an integer N. The task is to find the number of all possible distinct binary strings of length N which have at least 3 consecutive 1s.
Examples:
Input: N = 3
Output: 1
The only string of length 3 possible is “111”.
Input: N = 4
Output: 3
The 3 strings are “1110”, “0111” and “1111”.
Naive approach: Consider all possible strings.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function that returns true if s contains // three consecutive 1's bool check(string& s)
{ int n = s.length();
for ( int i = 2; i < n; i++) {
if (s[i] == '1' && s[i - 1] == '1' && s[i - 2] == '1' )
return 1;
}
return 0;
} // Function to return the count // of required strings int countStr( int i, string& s)
{ if (i < 0) {
if (check(s))
return 1;
return 0;
}
s[i] = '0' ;
int ans = countStr(i - 1, s);
s[i] = '1' ;
ans += countStr(i - 1, s);
s[i] = '0' ;
return ans;
} // Driver code int main()
{ int N = 4;
string s(N, '0' );
cout << countStr(N - 1, s);
return 0;
} |
// Java implementation of the approach import java.util.*;
class GFG
{ // Function that returns true if s contains // three consecutive 1's static boolean check(String s)
{ int n = s.length();
for ( int i = 2 ; i < n; i++)
{
if (s.charAt(i) == '1' &&
s.charAt(i- 1 ) == '1' &&
s.charAt(i- 2 ) == '1' )
return true ;
}
return false ;
} // Function to return the count // of required strings static int countStr( int i, String s)
{ if (i < 0 )
{
if (check(s))
return 1 ;
return 0 ;
}
char [] myNameChars = s.toCharArray();
myNameChars[i] = '0' ;
s = String.valueOf(myNameChars);
int ans = countStr(i - 1 , s);
char [] myChar = s.toCharArray();
myChar[i] = '1' ;
s = String.valueOf(myChar);
ans += countStr(i - 1 , s);
char []myChar1 = s.toCharArray();
myChar1[i] = '0' ;
s = String.valueOf(myChar1);
return ans;
} // Driver code public static void main(String args[])
{ int N = 4 ;
String s = "0000" ;
System.out.println(countStr(N - 1 , s));
} } // This code is contributed by // Surendra_Gangwar |
# Python3 implementation of the approach # Function that returns true if s contains # three consecutive 1's def check(s) :
n = len (s);
for i in range ( 2 , n) :
if (s[i] = = '1' and s[i - 1 ] = = '1' and
s[i - 2 ] = = '1' ) :
return 1 ;
# Function to return the count # of required strings def countStr(i, s) :
if (i < 0 ) :
if (check(s)) :
return 1 ;
return 0 ;
s[i] = '0' ;
ans = countStr(i - 1 , s);
s[i] = '1' ;
ans + = countStr(i - 1 , s);
s[i] = '0' ;
return ans;
# Driver code if __name__ = = "__main__" :
N = 4 ;
s = list ( '0' * N);
print (countStr(N - 1 , s));
# This code is contributed by Ryuga |
// C# implementation of the approach // value x using System;
class GFG
{ // Function that returns true if s contains // three consecutive 1's static bool check(String s)
{ int n = s.Length;
for ( int i = 2; i < n; i++)
{
if (s[i] == '1' && s[i - 1] == '1' && s[i - 2] == '1' )
return true ;
}
return false ;
} // Function to return the count // of required strings static int countStr( int i, String s)
{ if (i < 0)
{
if (check(s))
return 1;
return 0;
}
char [] myNameChars = s.ToCharArray();
myNameChars[i] = '0' ;
s = String.Join( "" , myNameChars);
int ans = countStr(i - 1, s);
char [] myChar = s.ToCharArray();
myChar[i] = '1' ;
s = String.Join( "" , myChar);
ans += countStr(i - 1, s);
char []myChar1 = s.ToCharArray();
myChar1[i] = '0' ;
s = String.Join( "" , myChar1);
return ans;
} // Driver code public static void Main(String []args)
{ int N = 4;
String s = "0000" ;
Console.WriteLine(countStr(N - 1, s));
} } /* This code contributed by PrinciRaj1992 */ |
<script> // JavaScript implementation of the approach // value x // Function that returns true if s contains // three consecutive 1's function check(s)
{ let n = s.length;
for (let i = 2; i < n; i++)
{
if (s[i] == '1 ' &&
s[i-1] == ' 1 ' &&
s[i-2] == ' 1 ')
return true;
}
return false;
} // Function to return the count // of required strings function countStr(i,s) { if (i < 0)
{
if (check(s))
return 1;
return 0;
}
let myNameChars = s.split("");
myNameChars[i] = ' 0 ';
s = (myNameChars).join("");
let ans = countStr(i - 1, s);
let myChar = s.split("");
myChar[i] = ' 1 ';
s = (myChar).join("");
ans += countStr(i - 1, s);
let myChar1 = s.split("");
myChar1[i] = ' 0';
s = (myChar1).join( "" );
return ans;
} // Driver code let N = 4; let s = "0000" ;
document.write(countStr(N - 1, s)); // This code is contributed by avanitrachhadiya2155 </script> |
3
Time Complexity: O(2N)
Space Complexity: O(N) because of recurrence stack space.
Efficient approach: We use dynamic programming for computing the number of strings.
State of dp: dp(i, x) : denotes number of strings of length i with x consecutive 1s in position i + 1 to i + x.
Recurrence: dp(i, x) = dp(i – 1, 0) + dp(i – 1, x + 1)
The recurrence is based on the fact that either the string can have a ‘0’ at position i or a ‘1’.
- If it has a ‘0’ at position i then for (i-1)th position value of x = 0.
- If it has a ‘1’ at position i the for (i-1)th position value of x = value of x at position i + 1.
Base Condition: dp(i, 3) = 2i. Because once you have 3 consecutive ‘1’s you don’t care what characters are there at position 1, 2…i of string as all the strings are valid.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
int n;
// Function to return the count // of required strings int solve( int i, int x, int dp[][4])
{ if (i < 0)
return x == 3;
if (dp[i][x] != -1)
return dp[i][x];
// '0' at ith position
dp[i][x] = solve(i - 1, 0, dp);
// '1' at ith position
dp[i][x] += solve(i - 1, x + 1, dp);
return dp[i][x];
} // Driver code int main()
{ n = 4;
int dp[n][4];
for ( int i = 0; i < n; i++)
for ( int j = 0; j < 4; j++)
dp[i][j] = -1;
for ( int i = 0; i < n; i++) {
// Base condition:
// 2^(i+1) because of 0 indexing
dp[i][3] = (1 << (i + 1));
}
cout << solve(n - 1, 0, dp);
return 0;
} |
// Java implementation of the above approach import java.util.*;
class GFG
{ static int n;
// Function to return the count
// of required strings
static int solve( int i, int x, int dp[][])
{
if (i < 0 )
{
return x == 3 ? 1 : 0 ;
}
if (dp[i][x] != - 1 )
{
return dp[i][x];
}
// '0' at ith position
dp[i][x] = solve(i - 1 , 0 , dp);
// '1' at ith position
dp[i][x] += solve(i - 1 , x + 1 , dp);
return dp[i][x];
}
// Driver code
public static void main(String[] args)
{
n = 4 ;
int dp[][] = new int [n][ 4 ];
for ( int i = 0 ; i < n; i++)
{
for ( int j = 0 ; j < 4 ; j++)
{
dp[i][j] = - 1 ;
}
}
for ( int i = 0 ; i < n; i++)
{
// Base condition:
// 2^(i+1) because of 0 indexing
dp[i][ 3 ] = ( 1 << (i + 1 ));
}
System.out.print(solve(n - 1 , 0 , dp));
}
} // This code has been contributed by 29AjayKumar |
# Python 3 implementation of the approach # Function to return the count # of required strings def solve(i, x, dp):
if (i < 0 ):
return x = = 3
if (dp[i][x] ! = - 1 ):
return dp[i][x]
# '0' at ith position
dp[i][x] = solve(i - 1 , 0 , dp)
# '1' at ith position
dp[i][x] + = solve(i - 1 , x + 1 , dp)
return dp[i][x]
# Driver code if __name__ = = "__main__" :
n = 4 ;
dp = [[ 0 for i in range (n)] for j in range ( 4 )]
for i in range (n):
for j in range ( 4 ):
dp[i][j] = - 1
for i in range (n) :
# Base condition:
# 2^(i+1) because of 0 indexing
dp[i][ 3 ] = ( 1 << (i + 1 ))
print (solve(n - 1 , 0 , dp))
# This code is contributed by ChitraNayal |
// C# implementation of the above approach using System;
class GFG
{ static int n;
// Function to return the count
// of required strings
static int solve( int i, int x, int [,]dp)
{
if (i < 0)
{
return x == 3 ? 1 : 0;
}
if (dp[i,x] != -1)
{
return dp[i,x];
}
// '0' at ith position
dp[i,x] = solve(i - 1, 0, dp);
// '1' at ith position
dp[i,x] += solve(i - 1, x + 1, dp);
return dp[i,x];
}
// Driver code
public static void Main(String[] args)
{
n = 4;
int [,]dp = new int [n, 4];
for ( int i = 0; i < n; i++)
{
for ( int j = 0; j < 4; j++)
{
dp[i, j] = -1;
}
}
for ( int i = 0; i < n; i++)
{
// Base condition:
// 2^(i+1) because of 0 indexing
dp[i,3] = (1 << (i + 1));
}
Console.Write(solve(n - 1, 0, dp));
}
} // This code contributed by Rajput-Ji |
<script> // Javascript implementation of the above approach var n;
// Function to return the count
// of required strings
function solve(i , x , dp)
{
if (i < 0) {
return x == 3 ? 1 : 0;
}
if (dp[i][x] != -1) {
return dp[i][x];
}
// '0' at ith position
dp[i][x] = solve(i - 1, 0, dp);
// '1' at ith position
dp[i][x] += solve(i - 1, x + 1, dp);
return dp[i][x];
}
// Driver code
n = 4;
var dp = Array(n).fill().map(()=>Array(4).fill(0));
for (i = 0; i < n; i++) {
for (j = 0; j < 4; j++) {
dp[i][j] = -1;
}
}
for (i = 0; i < n; i++) {
// Base condition:
// 2^(i+1) because of 0 indexing
dp[i][3] = (1 << (i + 1));
}
document.write(solve(n - 1, 0, dp));
// This code contributed by gauravrajput1 </script> |
3
Time complexity: O(N)
Space Complexity: O(N)