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

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”.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

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 `

Output:

```3
```

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

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.