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 <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 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 |
<?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 ?> |
<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> |
33554432
Time Complexity: O(logn)
Auxiliary Space: O(1)