Open In App

Count binary strings with twice zeros in first half

We are given an integer N. We need to count the total number of such binary strings of length N such that the number of ‘0’s in the first string of length N/2 is double of the number of ‘0’s in the second string of length N/2. 

Note: N is always an even positive integer.

Examples: 

Input : N = 4 
Output :
Explanation: 0010 and 0001 are two binary string such that the number of zero in the first half is double the number of zero in second half. 
  
Input : N = 6 
Output : 9

Naive Approach:We can generate all the binary string of length N and then one by one can check that whether selected string follows the given scenario. But the time complexity for this approach is exponential and is O(N*2N).

Efficient Approach: This approach is based on some mathematical analysis of the problem. 
Pre-requisite for this approach: Factorial and Combinatoric with modulo function. 
Note: Let n = N/2. 

If we perform some analysis step by step: 

  1. The number of strings which contain two ‘0’ in first half string and one ‘0’ in second half string, is equal to nC2 * nC1.
  2. The number of strings which contain four ‘0’ in first half string and two ‘0’ in second half string, is equal to nC4 * nC2.
  3. The number of strings which contain six ‘0’ in first half string and three ‘0’ in second half string, is equal to nC6 * nC3.

We repeat above procedure till the number of ‘0’ in first half become n if n is even or (n-1) if n is odd. 
So, our final answer is ? (nC(2*i) * nCi), for 2 <= 2*i <= n. 
Now, we can compute the required number of strings just by using Permutation and Combination.

Algorithm : 

int n = N/2;
for(int i=2;i<=n;i=i+2)
             ans += ( nCr(n, i) * nCr(n, i/2);

Note : You can use Dynamic Programming technique to pre-compute CoeFunc(N, i) i.e. nCi.
Time complexity is O(N) if we pre-compute CoeFunc(N, i) in O(N*N).  

Implementation:




// CPP for finding number of binary strings
// number of '0' in first half is double the
// number of '0' in second half of string
#include <bits/stdc++.h>
 
// pre define some constant
#define mod 1000000007
#define max 1001
using namespace std;
 
// global values for pre computation
long long int nCr[1003][1003];
 
void preComputeCoeff()
{
    for (int i = 0; i < max; i++) {
        for (int j = 0; j <= i; j++) {
            if (j == 0 || j == i)
                nCr[i][j] = 1;
            else
                nCr[i][j] = (nCr[i - 1][j - 1] +
                             nCr[i - 1][j]) % mod;
        }
    }
}
 
// function to print number of required string
long long int computeStringCount(int N)
{
    int n = N / 2;
    long long int ans = 0;
 
    // calculate answer using proposed algorithm
    for (int i = 2; i <= n; i += 2)
        ans = (ans + ((nCr[n][i] * nCr[n][i / 2])
                      % mod)) % mod;
    return ans;
}
 
// Driver code
int main()
{
    preComputeCoeff();
    int N = 3;
    cout << computeStringCount(N) << endl;
    return 0;
}




// Java program for finding number of binary strings
// number of '0' in first half is double the
// number of '0' in second half of string
class GFG {
     
    // pre define some constant
    static final long mod = 1000000007;
    static final long max = 1001;
     
    // global values for pre computation
    static long nCr[][] = new long[1003][1003];
     
    static void preComputeCoeff()
    {
        for (int i = 0; i < max; i++) {
            for (int j = 0; j <= i; j++) {
                if (j == 0 || j == i)
                    nCr[i][j] = 1;
                else
                    nCr[i][j] = (nCr[i - 1][j - 1] +
                                nCr[i - 1][j]) % mod;
            }
        }
    }
     
    // function to print number of required string
    static long computeStringCount(int N)
    {
        int n = N / 2;
        long ans = 0;
     
        // calculate answer using proposed algorithm
        for (int i = 2; i <= n; i += 2)
            ans = (ans + ((nCr[n][i] * nCr[n][i / 2])
                        % mod)) % mod;
        return ans;
    }
     
    // main function
    public static void main(String[] args)
    {
        preComputeCoeff();
        int N = 3;
        System.out.println( computeStringCount(N) );
         
    }
}
 
// This code is contributed by Arnab Kundu.




# Python3 for finding number of binary strings
# number of '0' in first half is double the
# number of '0' in second half of string
 
# pre define some constant
mod = 1000000007
Max = 1001
 
# global values for pre computation
nCr = [[0 for _ in range(1003)]
          for i in range(1003)]
 
def preComputeCoeff():
 
    for i in range(Max):
        for j in range(i + 1):
            if (j == 0 or j == i):
                nCr[i][j] = 1
            else:
                nCr[i][j] = (nCr[i - 1][j - 1] +
                             nCr[i - 1][j]) % mod
         
# function to print number of required string
def computeStringCount(N):
    n = N // 2
    ans = 0
 
    # calculate answer using proposed algorithm
    for i in range(2, n + 1, 2):
        ans = (ans + ((nCr[n][i] *
                       nCr[n][i // 2]) % mod)) % mod
    return ans
 
# Driver code
preComputeCoeff()
N = 3
print(computeStringCount(N))
 
# This code is contributed by mohit kumar




// C# program for finding number of binary
// strings number of '0' in first half is
// double the number of '0' in second half
// of string
using System;
 
class GFG {
     
    // pre define some constant
    static long mod = 1000000007;
    static long max = 1001;
     
    // global values for pre computation
    static long [,]nCr = new long[1003,1003];
     
    static void preComputeCoeff()
    {
        for (int i = 0; i < max; i++)
        {
            for (int j = 0; j <= i; j++)
            {
                if (j == 0 || j == i)
                    nCr[i,j] = 1;
                else
                    nCr[i,j] = (nCr[i - 1,j - 1]
                          + nCr[i - 1,j]) % mod;
            }
        }
    }
     
    // function to print number of required
    // string
    static long computeStringCount(int N)
    {
        int n = N / 2;
        long ans = 0;
     
        // calculate answer using proposed
        // algorithm
        for (int i = 2; i <= n; i += 2)
            ans = (ans + ((nCr[n,i]
                * nCr[n,i / 2]) % mod)) % mod;
                 
        return ans;
    }
     
    // main function
    public static void Main()
    {
        preComputeCoeff();
        int N = 3;
        Console.Write( computeStringCount(N) );
         
    }
}
 
// This code is contributed by nitin mittal.




<script>
 
 
// Javascript for finding number of binary strings
// number of '0' in first half is double the
// number of '0' in second half of string
 
// pre define some constant
var mod = 1000000007
var max = 1001
 
// global values for pre computation
var nCr = Array.from(Array(1003), ()=> Array(1003));
 
function preComputeCoeff()
{
    for (var i = 0; i < max; i++) {
        for (var j = 0; j <= i; j++) {
            if (j == 0 || j == i)
                nCr[i][j] = 1;
            else
                nCr[i][j] = (nCr[i - 1][j - 1] +
                             nCr[i - 1][j]) % mod;
        }
    }
}
 
// function to print number of required string
function computeStringCount(N)
{
    var n = N / 2;
    var ans = 0;
 
    // calculate answer using proposed algorithm
    for (var i = 2; i <= n; i += 2)
        ans = (ans + ((nCr[n][i] * nCr[n][i / 2])
                      % mod)) % mod;
    return ans;
}
 
// Driver code
preComputeCoeff();
var N = 3;
document.write( computeStringCount(N));
 
// This code is contributed by noob2000.
</script>

Output
0

Article Tags :