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

• Difficulty Level : Medium
• Last Updated : 05 May, 2021

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 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 = 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[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

 ``

Output:

`20`

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

My Personal Notes arrow_drop_up