Related Articles
Count number of binary strings of length N having only 0’s and 1’s
• Difficulty Level : Easy
• Last Updated : 22 Apr, 2021

Given an integer N, the task is to count the number of binary strings of length N having only 0’s and 1’s.
Note: Since the count can be very large, return the answer modulo 10^9+7.

Examples:

Input:
Output:
Explanation: The numbers are 00, 01, 11, 10. Hence the count is 4.

Input:
Output:
Explanation: The numbers are 000, 001, 011, 010, 111, 101, 110, 100. Hence the count is 8.

Approach: The problem can be easily solved by using Permutation and Combination. At each position of the string there can only be two possibilities, i.e., 0 or 1. Therefore, the total number of permutation of 0 and 1 in a string of length N is given by 2*2*2*…(N times), i.e., 2^N. The answer can be very large, hence modulo by 10^9+7 is returned.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;``#define ll long long``#define mod (ll)(1e9 + 7)` `// Iterative Function to calculate (x^y)%p in O(log y)``ll power(ll x, ll y, ll p)``{``    ``ll res = 1; ``// Initialize result` `    ``x = x % p; ``// Update x if it is more than or``    ``// equal to p` `    ``while` `(y > 0) {` `        ``// If y is odd, multiply x with result``        ``if` `(y & 1)``            ``res = (res * x) % p;` `        ``// y must be even now``        ``y = y >> 1; ``// y = y/2``        ``x = (x * x) % p;``    ``}``    ``return` `res;``}` `// Function to count the number of binary``// strings of length N having only 0's and 1's``ll findCount(ll N)``{``    ``int` `count = power(2, N, mod);``    ``return` `count;``}` `// Driver code``int` `main()``{``    ``ll N = 25;` `    ``cout << findCount(N);` `    ``return` `0;``}`

## Java

 `// Java implementation of the above approach``import` `java.util.*;` `class` `GFG``{` `static` `int` `mod = (``int``) (1e9 + ``7``);` `// Iterative Function to calculate (x^y)%p in O(log y)``static` `int` `power(``int` `x, ``int` `y, ``int` `p)``{``    ``int` `res = ``1``; ``// Initialize result` `    ``x = x % p; ``// Update x if it is more than or``    ``// equal to p` `    ``while` `(y > ``0``)``    ``{` `        ``// If y is odd, multiply x with result``        ``if` `((y & ``1``)==``1``)``            ``res = (res * x) % p;` `        ``// y must be even now``        ``y = y >> ``1``; ``// y = y/2``        ``x = (x * x) % p;``    ``}``    ``return` `res;``}` `// Function to count the number of binary``// strings of length N having only 0's and 1's``static` `int` `findCount(``int` `N)``{``    ``int` `count = power(``2``, N, mod);``    ``return` `count;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``        ``int` `N = ``25``;``        ``System.out.println(findCount(N));``}``}` `/* This code contributed by PrinciRaj1992 */`

## Python3

 `# Python 3 implementation of the approach``mod ``=` `1000000007` `# Iterative Function to calculate (x^y)%p in O(log y)``def` `power(x, y, p):``    ``res ``=` `1` `# Initialize result` `    ``x ``=` `x ``%` `p ``# Update x if it is more than or``              ``# equal to p` `    ``while` `(y > ``0``):``        ` `        ``# If y is odd, multiply x with result``        ``if` `(y & ``1``):``            ``res ``=` `(res ``*` `x) ``%` `p` `        ``# y must be even now``        ``y ``=` `y >> ``1` `# y = y/2``        ``x ``=` `(x ``*` `x) ``%` `p` `    ``return` `res` `# Function to count the number of binary``# strings of length N having only 0's and 1's``def` `findCount(N):``    ``count ``=` `power(``2``, N, mod)``    ``return` `count` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``N ``=` `25``    ``print``(findCount(N))` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# implementation of the above approach``using` `System;` `class` `GFG``{` `    ``static` `int` `mod = (``int``) (1e9 + 7);``    ` `    ``// Iterative Function to calculate (x^y)%p in O(log y)``    ``static` `int` `power(``int` `x, ``int` `y, ``int` `p)``    ``{``        ``int` `res = 1; ``// Initialize result``    ` `        ``x = x % p; ``// Update x if it is more than or``        ``// equal to p``    ` `        ``while` `(y > 0)``        ``{``    ` `            ``// If y is odd, multiply x with result``            ``if` `((y & 1) == 1)``                ``res = (res * x) % p;``    ` `            ``// y must be even now``            ``y = y >> 1; ``// y = y/2``            ``x = (x * x) % p;``        ``}``        ``return` `res;``    ``}``    ` `    ``// Function to count the number of binary``    ``// strings of length N having only 0's and 1's``    ``static` `int` `findCount(``int` `N)``    ``{``        ``int` `count = power(2, N, mod);``        ``return` `count;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``            ``int` `N = 25;``            ``Console.WriteLine(findCount(N));``    ``}``}` `// This code is contributed by Ryuga`

## PHP

 ` 0)``    ``{` `        ``// If y is odd, multiply x with result``        ``if` `(``\$y` `& 1)``            ``\$res` `= (``\$res` `* ``\$x``) % ``\$p``;` `        ``// y must be even now``        ``\$y` `= ``\$y` `>> 1; ``// y = y/2``        ``\$x` `= (``\$x` `* ``\$x``) % ``\$p``;``    ``}``    ``return` `\$res``;``}` `// Function to count the number of binary``// strings of length N having only 0's and 1's``function` `findCount(``\$N``)``{``    ``\$count` `= power(2, ``\$N``);``    ``return` `\$count``;``}` `// Driver code``\$N` `= 25;` `echo` `findCount(``\$N``);``    ` `// This code is contributed by Rajput-Ji``?>`

## Javascript

 ``
Output:
`33554432`

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 industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up