# 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 : 2

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*2^{N}).

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

- The number of strings which contain two ‘0’ in first half string and one ‘0’ in second half string, is equal to
.^{n}C_{2}*^{n}C_{1} - The number of strings which contain four ‘0’ in first half string and two ‘0’ in second half string, is equal to
.^{n}C_{4}*^{n}C_{2} - The number of strings which contain six ‘0’ in first half string and three ‘0’ in second half string, is equal to
.^{n}C_{6}*^{n}C_{3}

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 **Σ ( ^{n}C_{(2*i)} * ^{n}C_{i})**, 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. ^{n}C_{i}.

Time complexity is O(N) if we pre-compute CoeFunc(N, i) in O(N*N).

## CPP

`// 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; ` `} ` |

*chevron_right*

*filter_none*

## Java

`// 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. ` |

*chevron_right*

*filter_none*

## C#

`// 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. ` |

*chevron_right*

*filter_none*

**Output:**

0

## Recommended Posts:

- Count number of binary strings without consecutive 1's
- Count binary strings with k times appearing adjacent two set bits
- Count numbers having N 0's and and M 1's with no leading zeros
- Count Pairs Of Consecutive Zeros
- Maximum difference of zeros and ones in binary string
- Maximum consecutive one’s (or zeros) in a binary array
- Find all even length binary sequences with same sum of first and second half bits
- Maximum difference of zeros and ones in binary string | Set 2 (O(n) time)
- Count of strings that become equal to one of the two strings after one removal
- Add n binary strings
- Bitwise AND of N binary strings
- Program to add two binary strings
- Bitwise OR of N binary strings
- Count strings with consecutive 1's
- Count strings that end with the given pattern

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.