# 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:
The only string of length 3 possible is “111”.
Input: N = 4
Output:
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 ``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

 ``

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 ``using` `namespace` `std;` `int` `n;` `// Function to return the count``// of required strings``int` `solve(``int` `i, ``int` `x, ``int` `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``int` `main()``{``    ``n = 4;``    ``int` `dp[n];` `    ``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] = (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

 ``

Output:

`3`

Time complexity: O(N)
Space Complexity: O(N)

My Personal Notes arrow_drop_up