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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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

*chevron_right*

*filter_none*

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