# 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 **0**s and **1**s. If such string is possible of length **N**, print **-1**. **Note:** Since the count can be very large, return the answer modulo **10 ^{9}+7**.

**Examples:**

Input:N = 2Output:2Explanation:

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.

Hence, the answer is 2.Input:4Output:6Explanation:

Strings “0011”, “0101”, “0110”, “1100”, “1010” and “1001” have same frequency of 0s and 1s.

Hence, the answer is 6.

**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 permutations 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 = 10^{9}+ 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 <bits/stdc++.h>` `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

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

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

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

## Javascript

`<script>` `// Javascript program for the above approach` ` ` `var` `MOD = 1000000007;` ` ` `// Function to calculate C(n, r) % MOD` ` ` `// DP based approach` ` ` `function` `nCrModp(n , r) {` ` ` `// Corner case` ` ` `if` `(n % 2 == 1) {` ` ` `return` `-1;` ` ` `}` ` ` `// Stores the last row` ` ` `// of Pascal's Triangle` ` ` `var` `C = Array(r + 1).fill(0);` ` ` ` ` `// Initialize top row` ` ` `// of pascal triangle` ` ` `C[0] = 1;` ` ` `// Construct Pascal's Triangle` ` ` `// from top to bottom` ` ` `for` `(i = 1; i <= n; i++) {` ` ` `// Fill current row with the` ` ` `// help of previous row` ` ` `for` `(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` ` ` `var` `N = 6;` ` ` `document.write(nCrModp(N, N / 2));` `// This code contributed by gauravrajput1` `</script>` |

**Output:**

20

**Time Complexity: **O(N^{2}) **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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.