# Find all even length binary sequences with same sum of first and second half bits

Given a number n, find all binary sequences of length 2n such that sum of first n bits is same as sum of last n bits.

Examples:

```Input:  N = 2
Output:
0101 1111 1001 0110 0000 1010

Input:  N = 3
Output:
011011 001001 011101 010001 101011 111111
110011 101101 100001 110101 001010 011110
010010 001100 000000 010100 101110 100010
110110 100100
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The idea is to fix first and last bits and then recur for remaining 2*(n-1) bits. There are four possibilities when we fix first and last bits –

1. First and last bits are 1, remaining n – 1 bits on both sides should also have the same sum.
2. First and last bits are 0, remaining n – 1 bits on both sides should also have the same sum.
3. First bit is 1 and last bit is 0, sum of remaining n – 1 bits on left side should be 1 less than the sum n-1 bits on right side.
4. First bit is 0 and last bit is 1, sum of remaining n – 1 bits on left side should be 1 more than the sum n-1 bits on right side.

Below is implementation of above idea –

## C++

 `// C++ program to print even length binary sequences ` `// whose sum of first and second half bits is same ` `#include ` `using` `namespace` `std; ` ` `  `// Function to print even length binary sequences ` `// whose sum of first and second half bits is same ` ` `  `// diff --> difference between sums of first n bits ` `// and last n bits ` `// out --> output array ` `// start --> starting index ` `// end --> ending index ` `void` `findAllSequences(``int` `diff, ``char``* out, ``int` `start, ``int` `end) ` `{ ` `    ``// We can't cover difference of more than n with 2n bits ` `    ``if` `(``abs``(diff) > (end - start + 1) / 2) ` `        ``return``; ` ` `  `    ``// if all bits are filled ` `    ``if` `(start > end) ` `    ``{ ` `        ``// if sum of first n bits and last n bits are same ` `        ``if` `(diff == 0) ` `            ``cout << out << ``" "``; ` `        ``return``; ` `    ``} ` ` `  `    ``// fill first bit as 0 and last bit as 1 ` `    ``out[start] = ``'0'``, out[end] = ``'1'``; ` `    ``findAllSequences(diff + 1, out, start + 1, end - 1); ` ` `  `    ``// fill first and last bits as 1 ` `    ``out[start] = out[end] = ``'1'``; ` `    ``findAllSequences(diff, out, start + 1, end - 1); ` ` `  `    ``// fill first and last bits as 0 ` `    ``out[start] = out[end] = ``'0'``; ` `    ``findAllSequences(diff, out, start + 1, end - 1); ` ` `  `    ``// fill first bit as 1 and last bit as 0 ` `    ``out[start] = ``'1'``, out[end] = ``'0'``; ` `    ``findAllSequences(diff - 1, out, start + 1, end - 1); ` `} ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``// input number ` `    ``int` `n = 2; ` ` `  `    ``// allocate string contaning 2*n characters ` `    ``char` `out[2 * n + 1]; ` ` `  `    ``// null terminate output array ` `    ``out[2 * n] = ``'\0'``; ` ` `  `    ``findAllSequences(0, out, 0, 2*n - 1); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to print even length binary  ` `// sequences whose sum of first and second ` `// half bits is same ` `import` `java.io.*; ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` `    ``// Function to print even length binary sequences ` `    ``// whose sum of first and second half bits is same ` `  `  `    ``// diff --> difference between sums of first n bits ` `    ``// and last n bits ` `    ``// out --> output array ` `    ``// start --> starting index ` `    ``// end --> ending index ` `    ``static` `void` `findAllSequences(``int` `diff, ``char` `out[],  ` `                                     ``int` `start, ``int` `end) ` `    ``{ ` `        ``// We can't cover difference of more  ` `        ``// than n with 2n bits ` `        ``if` `(Math.abs(diff) > (end - start + ``1``) / ``2``) ` `            ``return``; ` `  `  `        ``// if all bits are filled ` `        ``if` `(start > end) ` `        ``{ ` `            ``// if sum of first n bits and ` `            ``// last n bits are same ` `            ``if` `(diff == ``0``) ` `            ``{ ` `                ``System.out.print(out); ` `                ``System.out.print(``" "``); ` `            ``}     ` `            ``return``; ` `        ``} ` `  `  `        ``// fill first bit as 0 and last bit as 1 ` `        ``out[start] = ``'0'``; ` `        ``out[end] = ``'1'``; ` `        ``findAllSequences(diff + ``1``, out, start + ``1``, end - ``1``); ` `  `  `        ``// fill first and last bits as 1 ` `        ``out[start] = out[end] = ``'1'``; ` `        ``findAllSequences(diff, out, start + ``1``, end - ``1``); ` `  `  `        ``// fill first and last bits as 0 ` `        ``out[start] = out[end] = ``'0'``; ` `        ``findAllSequences(diff, out, start + ``1``, end - ``1``); ` `  `  `        ``// fill first bit as 1 and last bit as 0 ` `        ``out[start] = ``'1'``; ` `        ``out[end] = ``'0'``; ` `        ``findAllSequences(diff - ``1``, out, start + ``1``, end - ``1``); ` `    ``} ` `     `  `    ``// Driver program ` `    ``public` `static` `void` `main (String[] args)  ` `    ``{ ` `        ``// input number ` `        ``int` `n = ``2``; ` `  `  `        ``// allocate string contaning 2*n characters ` `        ``char``[] out = ``new` `char``[``2` `* n + ``1``]; ` `  `  `        ``// null terminate output array ` `        ``out[``2` `* n] = ``'\0'``; ` `  `  `        ``findAllSequences(``0``, out, ``0``, ``2``*n - ``1``); ` `    ``} ` `} ` ` `  `// This code is contributed by Pramod Kumar `

## Python3

 `# Python3 program to print even length binary sequences ` `# whose sum of first and second half bits is same ` ` `  `# Function to print even length binary sequences ` `# whose sum of first and second half bits is same ` ` `  `# diff --> difference between sums of first n bits ` `# and last n bits ` `# out --> output array ` `# start --> starting index ` `# end --> ending index ` `def` `findAllSequences(diff, out, start, end): ` ` `  `    ``# We can't cover difference of more than n with 2n bits ` `    ``if` `(``abs``(diff) > (end ``-` `start ``+` `1``) ``/``/` `2``): ` `        ``return``; ` ` `  `    ``# if all bits are filled ` `    ``if` `(start > end): ` `        ``# if sum of first n bits and last n bits are same ` `        ``if` `(diff ``=``=` `0``): ` `            ``print``(''.join(``list``(out)),end``=``" "``); ` `        ``return``; ` ` `  `    ``# fill first bit as 0 and last bit as 1 ` `    ``out[start] ``=` `'0'``; ` `    ``out[end] ``=` `'1'``; ` `    ``findAllSequences(diff ``+` `1``, out, start ``+` `1``, end ``-` `1``); ` ` `  `    ``# fill first and last bits as 1 ` `    ``out[start] ``=` `out[end] ``=` `'1'``; ` `    ``findAllSequences(diff, out, start ``+` `1``, end ``-` `1``); ` ` `  `    ``# fill first and last bits as 0 ` `    ``out[start] ``=` `out[end] ``=` `'0'``; ` `    ``findAllSequences(diff, out, start ``+` `1``, end ``-` `1``); ` ` `  `    ``# fill first bit as 1 and last bit as 0 ` `    ``out[start] ``=` `'1'``; ` `    ``out[end] ``=` `'0'``; ` `    ``findAllSequences(diff ``-` `1``, out, start ``+` `1``, end ``-` `1``); ` ` `  `# Driver program ` ` `  `# input number ` `n ``=` `2``; ` ` `  `# allocate string contaning 2*n characters ` `out``=``[""]``*``(``2``*``n); ` ` `  `findAllSequences(``0``, out, ``0``, ``2``*``n ``-` `1``); ` ` `  `# This code is contributed by mits `

## C#

 `// C# program to print even length binary  ` `// sequences whose sum of first and second ` `// half bits is same ` `using` `System; ` ` `  `class` `GFG { ` `     `  `    ``// Function to print even length binary ` `    ``// sequences whose sum of first and  ` `    ``// second half bits is same ` ` `  `    ``// diff --> difference between sums of ` `    ``// first n bits ` `    ``// and last n bits ` `    ``// out --> output array ` `    ``// start --> starting index ` `    ``// end --> ending index ` `    ``static` `void` `findAllSequences(``int` `diff, ` `            ``char` `[]outt, ``int` `start, ``int` `end) ` `    ``{ ` `         `  `        ``// We can't cover difference of  ` `        ``// more than n with 2n bits ` `        ``if` `(Math.Abs(diff) > (end - start ` `                                   ``+ 1) / 2) ` `            ``return``; ` ` `  `        ``// if all bits are filled ` `        ``if` `(start > end) ` `        ``{ ` `             `  `            ``// if sum of first n bits and ` `            ``// last n bits are same ` `            ``if` `(diff == 0) ` `            ``{ ` `                ``Console.Write(outt); ` `                ``Console.Write(``" "``); ` `            ``}  ` `            ``return``; ` `        ``} ` ` `  `        ``// fill first bit as 0 and last bit ` `        ``// as 1 ` `        ``outt[start] = ``'0'``; ` `        ``outt[end] = ``'1'``; ` `        ``findAllSequences(diff + 1, outt,  ` `                        ``start + 1, end - 1); ` ` `  `        ``// fill first and last bits as 1 ` `        ``outt[start] = outt[end] = ``'1'``; ` `        ``findAllSequences(diff, outt,  ` `                        ``start + 1, end - 1); ` ` `  `        ``// fill first and last bits as 0 ` `        ``outt[start] = outt[end] = ``'0'``; ` `        ``findAllSequences(diff, outt,  ` `                         ``start + 1, end - 1); ` ` `  `        ``// fill first bit as 1 and last  ` `        ``// bit as 0 ` `        ``outt[start] = ``'1'``; ` `        ``outt[end] = ``'0'``; ` `        ``findAllSequences(diff - 1, outt, ` `                         ``start + 1, end - 1); ` `    ``} ` `     `  `    ``// Driver program ` `    ``public` `static` `void` `Main ()  ` `    ``{ ` `         `  `        ``// input number ` `        ``int` `n = 2; ` ` `  `        ``// allocate string contaning 2*n  ` `        ``// characters ` `        ``char` `[]outt = ``new` `char``[2 * n + 1]; ` ` `  `        ``// null terminate output array ` `        ``outt[2 * n] = ``'\0'``; ` ` `  `        ``findAllSequences(0, outt, 0, 2*n - 1); ` `    ``} ` `} ` ` `  `// This code is contributed by nitin mittal. `

## PHP

 ` difference between sums of first n bits ` `// and last n bits ` `// out --> output array ` `// start --> starting index ` `// end --> ending index ` `function` `findAllSequences(``\$diff``, ``\$out``, ``\$start``, ``\$end``) ` `{ ` `    ``// We can't cover difference of more than n with 2n bits ` `    ``if` `(``abs``(``\$diff``) > (int)((``\$end` `- ``\$start` `+ 1) / 2)) ` `        ``return``; ` ` `  `    ``// if all bits are filled ` `    ``if` `(``\$start` `> ``\$end``) ` `    ``{ ` `        ``// if sum of first n bits and last n bits are same ` `        ``if` `(``\$diff` `== 0) ` `            ``print``(implode(``""``,``\$out``).``" "``); ` `        ``return``; ` `    ``} ` ` `  `    ``// fill first bit as 0 and last bit as 1 ` `    ``\$out``[``\$start``] = ``'0'``; ` `    ``\$out``[``\$end``] = ``'1'``; ` `    ``findAllSequences(``\$diff` `+ 1, ``\$out``, ``\$start` `+ 1, ``\$end` `- 1); ` ` `  `    ``// fill first and last bits as 1 ` `    ``\$out``[``\$start``] = ``\$out``[``\$end``] = ``'1'``; ` `    ``findAllSequences(``\$diff``, ``\$out``, ``\$start` `+ 1, ``\$end` `- 1); ` ` `  `    ``// fill first and last bits as 0 ` `    ``\$out``[``\$start``] = ``\$out``[``\$end``] = ``'0'``; ` `    ``findAllSequences(``\$diff``, ``\$out``, ``\$start` `+ 1, ``\$end` `- 1); ` ` `  `    ``// fill first bit as 1 and last bit as 0 ` `    ``\$out``[``\$start``] = ``'1'``; ` `    ``\$out``[``\$end``] = ``'0'``; ` `    ``findAllSequences(``\$diff` `- 1, ``\$out``, ``\$start` `+ 1, ``\$end` `- 1); ` `} ` ` `  `// Driver program ` ` `  `    ``// input number ` `    ``\$n` `= 2; ` ` `  `    ``// allocate string contaning 2*n characters ` `    ``\$out``=``array_fill``(0,2*``\$n``,``""``); ` ` `  `    ``findAllSequences(0, ``\$out``, 0, 2*``\$n` `- 1); ` ` `  `// This code is contributed by chandan_jnu ` `?> `

Output:

```0101 1111 1001 0110 0000 1010
```