# 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).

## C++

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

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

`# 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#

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

## Javascript

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