# Count number of binary strings of length N having only 0’s and 1’s

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: 2
Output: 4
Explanation: The numbers are 00, 01, 11, 10. Hence the count is 4.

Input: 3
Output: 8
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++ 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 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 */`

 `# 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# 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  `

 ` 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 ` `?> `

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.

Article Tags :