Skip to content
Related Articles

Related Articles

Improve Article

Find the number of binary strings of length N with at least 3 consecutive 1s

  • Difficulty Level : Hard
  • Last Updated : 31 May, 2021

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++




// 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



// 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



# 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#



// 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 */
Javascript



<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>
Output: 


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’. 
 
  1. If it has a ‘0’ at position i then for (i-1)th position value of x = 0.
  2. 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++



// 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



// 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



# 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#



// 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
Javascript



<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>
Output: 
3
 
Time complexity: O(N) 
Space Complexity: O(N)
 
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
Previous
Count distinct points visited on the number line
Next

Minimum number of given operations required to convert a permutation into an identity permutation
Recommended Articles
Page :
Count possible binary strings of length N without P consecutive 0s and Q consecutive 1s
09, Oct 20
Count of binary strings of given length consisting of at least one 1
30, Jun 20
Count binary strings of length same as given string after removal of substrings "01" and "00" that consists of at least one '1'
18, Nov 20
Count of Binary strings of length N having atmost M consecutive 1s or 0s alternatively exactly K times
12, May 20
Count of binary strings of length N with even set bit count and at most K consecutive 1s
25, Jun 20
LCS formed by consecutive segments of at least length K
27, Jan 18
Partition a string into palindromic strings of at least length 2 with every character present in a single string
23, Mar 21
Generate a Binary String without any consecutive 0's and at most K consecutive 1's
29, Jul 20
Count number of binary strings without consecutive 1's
19, Jun 14
Count number of binary strings without consecutive 1’s : Set 2
03, Apr 20
Generate all binary strings without consecutive 1's
16, Jan 17
Minimum sum subsequence such that at least one of every four consecutive elements is picked
02, Jan 17
Minimum bit flips such that every K consecutive bits contain at least one set bit
11, Jun 20
Length of longest consecutive ones by at most one swap in a Binary String
06, Dec 18
Maximum length of consecutive 1's in a binary string in Python using Map function
07, Dec 17
Least number of manipulations needed to ensure two strings have identical characters
23, Aug 17
Count of same length Strings that exists lexicographically in between two given Strings
03, Apr 20
Check whether two strings can be made equal by reversing substring of equal length from both strings
15, Jul 20
Print all strings of maximum length from an array of strings
02, Sep 20
Number of Binary Strings of length N with K adjacent Set Bits
11, Dec 18
Count number of binary strings such that there is no substring of length greater than or equal to 3 with all 1's
30, Sep 19
Number of binary strings such that there is no substring of length ≥ 3
20, Jan 20
Find two equal subsequences of maximum length with at least one different index
29, Jan 20
Convert a number of length N such that it contains any one digit at least 'K' times
24, Oct 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Username247
@Username247
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox