# Count number of binary strings without consecutive 1’s

Given a positive integer N, count all possible distinct binary strings of length N such that there are no consecutive 1’s.

Examples:

Input: N = 2 Output: 3 // The 3 strings are 00, 01, 10 Input: N = 3 Output: 5 // The 5 strings are 000, 001, 010, 100, 101

This problem can be solved using Dynamic Programming. Let a[i] be the number of binary strings of length i which do not contain any two consecutive 1’s and which end in 0. Similarly, let b[i] be the number of such strings which end in 1. We can append either 0 or 1 to a string ending in 0, but we can only append 0 to a string ending in 1. This yields the recurrence relation:

a[i] = a[i - 1] + b[i - 1] b[i] = a[i - 1]

The base cases of above recurrence are a[1] = b[1] = 1. The total number of strings of length i is just a[i] + b[i].

Following is the implementation of above solution. In the following implementation, indexes start from 0. So a[i] represents the number of binary strings for input length i+1. Similarly, b[i] represents binary strings for input length i+1.

## C++

`// C++ program to count all distinct binary strings ` `// without two consecutive 1's ` `#include <iostream> ` `using` `namespace` `std; ` ` ` `int` `countStrings(` `int` `n) ` `{ ` ` ` `int` `a[n], b[n]; ` ` ` `a[0] = b[0] = 1; ` ` ` `for` `(` `int` `i = 1; i < n; i++) ` ` ` `{ ` ` ` `a[i] = a[i-1] + b[i-1]; ` ` ` `b[i] = a[i-1]; ` ` ` `} ` ` ` `return` `a[n-1] + b[n-1]; ` `} ` ` ` ` ` `// Driver program to test above functions ` `int` `main() ` `{ ` ` ` `cout << countStrings(3) << endl; ` ` ` `return` `0; ` `}` |

*chevron_right*

*filter_none*

## Java

`class` `Subset_sum ` `{ ` ` ` `static` `int` `countStrings(` `int` `n) ` ` ` `{ ` ` ` `int` `a[] = ` `new` `int` `[n]; ` ` ` `int` `b[] = ` `new` `int` `[n]; ` ` ` `a[` `0` `] = b[` `0` `] = ` `1` `; ` ` ` `for` `(` `int` `i = ` `1` `; i < n; i++) ` ` ` `{ ` ` ` `a[i] = a[i-` `1` `] + b[i-` `1` `]; ` ` ` `b[i] = a[i-` `1` `]; ` ` ` `} ` ` ` `return` `a[n-` `1` `] + b[n-` `1` `]; ` ` ` `} ` ` ` `/* Driver program to test above function */` ` ` `public` `static` `void` `main (String args[]) ` ` ` `{ ` ` ` `System.out.println(countStrings(` `3` `)); ` ` ` `} ` `}` `/* This code is contributed by Rajat Mishra */` |

*chevron_right*

*filter_none*

## Python3

`# Python program to count ` `# all distinct binary strings ` `# without two consecutive 1's ` ` ` `def` `countStrings(n): ` ` ` ` ` `a` `=` `[` `0` `for` `i ` `in` `range` `(n)] ` ` ` `b` `=` `[` `0` `for` `i ` `in` `range` `(n)] ` ` ` `a[` `0` `] ` `=` `b[` `0` `] ` `=` `1` ` ` `for` `i ` `in` `range` `(` `1` `,n): ` ` ` `a[i] ` `=` `a[i` `-` `1` `] ` `+` `b[i` `-` `1` `] ` ` ` `b[i] ` `=` `a[i` `-` `1` `] ` ` ` ` ` `return` `a[n` `-` `1` `] ` `+` `b[n` `-` `1` `] ` ` ` `# Driver program to test ` `# above functions ` ` ` `print` `(countStrings(` `3` `)) ` ` ` `# This code is contributed ` `# by Anant Agarwal. ` |

*chevron_right*

*filter_none*

## C#

`// C# program to count all distinct binary ` `// strings without two consecutive 1's ` `using` `System; ` ` ` `class` `Subset_sum ` `{ ` ` ` `static` `int` `countStrings(` `int` `n) ` ` ` `{ ` ` ` `int` `[]a = ` `new` `int` `[n]; ` ` ` `int` `[]b = ` `new` `int` `[n]; ` ` ` `a[0] = b[0] = 1; ` ` ` `for` `(` `int` `i = 1; i < n; i++) ` ` ` `{ ` ` ` `a[i] = a[i-1] + b[i-1]; ` ` ` `b[i] = a[i-1]; ` ` ` `} ` ` ` `return` `a[n-1] + b[n-1]; ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `Main () ` ` ` `{ ` ` ` `Console.Write(countStrings(3)); ` ` ` `} ` `} ` ` ` `// This code is contributed by nitin mittal ` |

*chevron_right*

*filter_none*

## PHP

`<?php ` `// PHP program to count all distinct ` `// binary stringswithout two ` `// consecutive 1's ` ` ` `function` `countStrings(` `$n` `) ` `{ ` ` ` `$a` `[` `$n` `] = 0; ` ` ` `$b` `[` `$n` `] = 0; ` ` ` `$a` `[0] = ` `$b` `[0] = 1; ` ` ` `for` `(` `$i` `= 1; ` `$i` `< ` `$n` `; ` `$i` `++) ` ` ` `{ ` ` ` `$a` `[` `$i` `] = ` `$a` `[` `$i` `- 1] + ` ` ` `$b` `[` `$i` `- 1]; ` ` ` `$b` `[` `$i` `] = ` `$a` `[` `$i` `- 1]; ` ` ` `} ` ` ` `return` `$a` `[` `$n` `- 1] + ` ` ` `$b` `[` `$n` `- 1]; ` `} ` ` ` ` ` `// Driver Code ` ` ` `echo` `countStrings(3) ; ` ` ` `// This code is contributed by nitin mittal ` `?> ` |

*chevron_right*

*filter_none*

Output:

5

**Source:**

courses.csail.mit.edu/6.006/oldquizzes/solutions/q2-f2009-sol.pdf

If we take a closer look at the pattern, we can observe that the count is actually (n+2)’th Fibonacci number for n >= 1. The Fibonacci Numbers are 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 141, ….

n = 1, count = 2 = fib(3) n = 2, count = 3 = fib(4) n = 3, count = 5 = fib(5) n = 4, count = 8 = fib(6) n = 5, count = 13 = fib(7) ................

Therefore we can count the strings in O(Log n) time also using the method 5 here.

**Related Post : **

1 to n bit numbers with no consecutive 1s in binary representation.

This article is contributed by **Rahul Jain**. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

## Recommended Posts:

- Find the number of binary strings of length N with at least 3 consecutive 1s
- Count number of binary strings such that there is no substring of length greater than or equal to 3 with all 1's
- Count strings with consecutive 1's
- Count of sub-strings with equal consecutive 0's and 1's
- Count binary strings with twice zeros in first half
- Count of non-overlapping sub-strings "101" and "010" in the given binary string
- Python | Check if there are K consecutive 1's in a binary number
- Count binary strings with k times appearing adjacent two set bits
- Maximum number of consecutive 1's in binary representation of all the array elements
- Count minimum number of subsets (or subsequences) with consecutive numbers
- Minimum number of Binary strings to represent a Number
- Number of binary strings such that there is no substring of length ≥ 3
- Number of sub-strings in a given binary string divisible by 2
- Number of Binary Strings of length N with K adjacent Set Bits
- Given a binary string, count number of substrings that start and end with 1.