Skip to content
Related Articles

Related Articles

Improve Article

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 <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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :