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

Input:3Output:8Explanation: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 <bits/stdc++.h>` `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

`<?php` `// PHP implementation of the approach` `// Iterative Function to calculate` `// (x^y)%p in O(log y)` `function` `power(` `$x` `, ` `$y` `)` `{` ` ` `$p` `= 1000000007;` ` ` `$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` `function` `findCount(` `$N` `)` `{` ` ` `$count` `= power(2, ` `$N` `);` ` ` `return` `$count` `;` `}` `// Driver code` `$N` `= 25;` `echo` `findCount(` `$N` `);` ` ` `// This code is contributed by Rajput-Ji` `?>` |

## Javascript

`<script>` `// Javascript implementation of the approach` `mod = 1000000007` `// Iterative Function to calculate` `// (x^y)%p in O(log y)` `function` `power(x, y, p)` `{` ` ` ` ` `// Initialize result` ` ` `var` `res = 1;` ` ` ` ` `// Update x if it is more than or` ` ` `// equal to p` ` ` `x = x % 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` `function` `findCount(N)` `{` ` ` `var` `count = power(2, N, mod);` ` ` `return` `count;` `}` `// Driver code` `var` `N = 25;` `document.write(findCount(N));` `// This code is contributed by noob2000` `</script>` |

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