Open In App

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

Last Updated : 31 May, 2021
Comments
Improve
Suggest changes
Like Article
Like
Report

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)
 


Next Article
Count total set bits in all numbers from 1 to N | Set 3

U
Username247
Improve
Article Tags :
Practice Tags :

Similar Reads

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