# 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++ 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[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 = 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 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 `

 `# Python3 program to implement ` `# the above approach ` `MOD ``=` `1000000007` ` `  `# Function to calculate C(n, r) % MOD  ` `# DP based approach  ` `def` `nCrModp (n, r): ` ` `  `    ``# Corner case ` `    ``if` `(n ``%` `2` `=``=` `1``): ` `        ``return` `-``1` ` `  `    ``# Stores the last row  ` `    ``# of Pascal's Triangle ` `    ``C ``=` `[``0``] ``*` `(r ``+` `1``) ` ` `  `    ``# Initialize top row  ` `    ``# of pascal triangle  ` `    ``C[``0``] ``=` `1` ` `  `    ``# Construct Pascal's Triangle  ` `    ``# from top to bottom  ` `    ``for` `i ``in` `range``(``1``, n ``+` `1``): ` ` `  `        ``# Fill current row with the  ` `        ``# help of previous row  ` `        ``for` `j ``in` `range``(``min``(i, r), ``0``, ``-``1``): ` ` `  `            ``# 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 ` `N ``=` `6` ` `  `print``(nCrModp(N, N ``/``/` `2``)) ` ` `  `# This code is contributed by himanshu77 `

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