# Count of binary strings of length N having equal count of 0’s and 1’s

Given an integer N, the task is to find the number of binary strings possible of length N having same frequency of 0s and 1s. If such string is possible of length N, print -1
Note: Since the count can be very large, return the answer modulo 109+7.
Examples:

Input: N = 2
Output:
Explanation:
All possible binary strings of length 2 are “00”, “01”, “10” and “11”.
Among them, “10” and “01” have the same frequency of 0s and 1s.
Input:
Output:
Explanation:
Strings “0011”, “0101”, “0110”, “1100”, “1010” and “1001” have same frequency of 0s and 1s.

Naive Approach:
The simplest approach is to generate all possible permutations of a string of length N having equal number of ‘0’ and ‘1’. For every permutation generated, increase the count. Print the total count of permutatiosn generated.
Time Complexity: O(N*N!)
Auxiliary Space: O(N)
Efficient Approach:
The above approach can be optimized by using concepts of Permutation and Combination. Follow the steps below to solve the problem:

• Since N positions need to be filled with equal number of 0‘s and 1‘s, select N/2 positions from the N positions in C(N, N/2) % mod( where mod = 109 + 7) ways to fill with only 1’s.
• Fill the remaining positions in C(N/2, N/2) % mod (i.e 1) way with only 0’s.

Below is the implementation of the above approach:

## C++

 `// C++ Program to implement ` `// the above approach ` `#include ` `using` `namespace` `std; ` `#define MOD 1000000007 ` ` `  `// Function to calculate C(n, r) % MOD ` `// DP based approach ` `int` `nCrModp(``int` `n, ``int` `r) ` `{ ` `    ``// Corner case ` `    ``if` `(n % 2 == 1) { ` `        ``return` `-1; ` `    ``} ` ` `  `    ``// Stores the last row ` `    ``// of Pascal's Triangle ` `    ``int` `C[r + 1]; ` ` `  `    ``memset``(C, 0, ``sizeof``(C)); ` ` `  `    ``// Initialize top row ` `    ``// of pascal triangle ` `    ``C = 1; ` ` `  `    ``// Construct Pascal's Triangle ` `    ``// from top to bottom ` `    ``for` `(``int` `i = 1; i <= n; i++) { ` ` `  `        ``// Fill current row with the ` `        ``// help of previous row ` `        ``for` `(``int` `j = min(i, r); j > 0; ` `            ``j--) ` ` `  `            ``// C(n, j) = C(n-1, j) ` `            ``// + C(n-1, j-1) ` `            ``C[j] = (C[j] + C[j - 1]) ` `                ``% MOD; ` `    ``} ` ` `  `    ``return` `C[r]; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``int` `N = 6; ` `    ``cout << nCrModp(N, N / 2); ` `    ``return` `0; ` `} `

## Java

 `// Java program for the above approach ` `import` `java.util.*; ` ` `  `class` `GFG{ ` `     `  `final` `static` `int` `MOD = ``1000000007``; ` `     `  `// Function to calculate C(n, r) % MOD ` `// DP based approach ` `static` `int` `nCrModp(``int` `n, ``int` `r) ` `{ ` ` `  `    ``// Corner case ` `    ``if` `(n % ``2` `== ``1``) ` `    ``{ ` `        ``return` `-``1``; ` `    ``} ` ` `  `    ``// Stores the last row ` `    ``// of Pascal's Triangle ` `    ``int` `C[] = ``new` `int``[r + ``1``]; ` ` `  `    ``Arrays.fill(C, ``0``); ` ` `  `    ``// Initialize top row ` `    ``// of pascal triangle ` `    ``C[``0``] = ``1``; ` ` `  `    ``// Construct Pascal's Triangle ` `    ``// from top to bottom ` `    ``for``(``int` `i = ``1``; i <= n; i++) ` `    ``{ ` ` `  `        ``// Fill current row with the ` `        ``// help of previous row ` `        ``for``(``int` `j = Math.min(i, r);  ` `                ``j > ``0``; j--) ` ` `  `            ``// C(n, j) = C(n-1, j) ` `            ``// + C(n-1, j-1) ` `            ``C[j] = (C[j] + C[j - ``1``]) % MOD; ` `    ``} ` `    ``return` `C[r]; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String s[]) ` `{ ` `    ``int` `N = ``6``; ` `    ``System.out.println(nCrModp(N, N / ``2``)); ` `}  ` `} ` ` `  `// This code is contributed by rutvik_56 `

## C#

 `// C# program for the above approach ` `using` `System; ` ` `  `class` `GFG{ ` `     `  `static` `int` `MOD = 1000000007; ` ` `  `// Function to calculate C(n, r) % MOD ` `// DP based approach ` `static` `int` `nCrModp(``int` `n, ``int` `r) ` `{ ` `     `  `    ``// Corner case ` `    ``if` `(n % 2 == 1) ` `    ``{ ` `        ``return` `-1; ` `    ``} ` ` `  `    ``// Stores the last row ` `    ``// of Pascal's Triangle ` `    ``int``[] C = ``new` `int``[r + 1]; ` ` `  `    ``// Initialize top row ` `    ``// of pascal triangle ` `    ``C = 1; ` ` `  `    ``// Construct Pascal's Triangle ` `    ``// from top to bottom ` `    ``for``(``int` `i = 1; i <= n; i++) ` `    ``{ ` ` `  `        ``// Fill current row with the ` `        ``// help of previous row ` `        ``for``(``int` `j = Math.Min(i, r);  ` `                ``j > 0; j--) ` ` `  `            ``// C(n, j) = C(n-1, j) ` `            ``// + C(n-1, j-1) ` `            ``C[j] = (C[j] + C[j - 1]) % MOD; ` `    ``} ` `    ``return` `C[r]; ` `} ` ` `  `// Driver code ` `static` `void` `Main()  ` `{ ` `    ``int` `N = 6; ` `    ``Console.WriteLine(nCrModp(N, N / 2)); ` `} ` `} ` ` `  `// This code is contributed by divyeshrabadiya07 `

Output:

```20
```

Time Complexity: O(N2
Space Complexity: O(N)

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.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

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.

2

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.