// 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 containing 2*n characters  char out[2 * n + 1];  // null terminate output array  out[2 * n] = '';  findAllSequences(0 out 0 2*n - 1);  return 0; } 

// 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 containing 2*n characters  char[] out = new char[2 * n + 1];    // null terminate output array  out[2 * n] = '';    findAllSequences(0 out 0 2*n - 1);  } } // This code is contributed by Pramod Kumar 

# 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 containing 2*n characters out=['']*(2*n); findAllSequences(0 out 0 2*n - 1); # This code is contributed by mits 

// 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 containing 2*n   // characters  char []outt = new char[2 * n + 1];  // null terminate output array  outt[2 * n] = '';  findAllSequences(0 outt 0 2*n - 1);  } } // This code is contributed by nitin mittal. 

 // PHP 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 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 containing 2*n characters $out=array_fill(02*$n''); findAllSequences(0 $out 0 2*$n - 1); // This code is contributed by chandan_jnu ?> 

<script>  // JavaScript 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  function findAllSequences(diff outt start end)  {    // We can't cover difference of  // more than n with 2n bits  if (Math.abs(diff) > parseInt((end - start + 1) / 2 10))  return;    // if all bits are filled  if (start > end)  {    // if sum of first n bits and  // last n bits are same  if (diff == 0)  {  document.write(outt.join(''));  document.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);  }    // input number  let n = 2;  // allocate string containing 2*n  // characters  let outt = new Array(2 * n + 1);  // null terminate output array  outt[2 * n] = '';  findAllSequences(0 outt 0 2*n - 1);   </script> 

// C++ program to implement the approach #include    using namespace std; //function that generates the sequence void generateSequencesWithSum(  int n vector<vector<string> >& sumToString  vector<string> sequence int sumSoFar) {  // Base case if there are no more binary digits to  // include  if (n == 0) {  // add permutation to list of sequences with sum  // corresponding to index  string seq = '';  for (int i = 0; i < sequence.size(); i++) {  seq = seq + sequence[i];  }  vector<string> x = sumToString[sumSoFar];  x.push_back(seq);  sumToString[sumSoFar] = x;  return;  }  // Generate sequence +0  sequence.push_back('0');  generateSequencesWithSum(n - 1 sumToString sequence  sumSoFar);  sequence.erase(sequence.begin());  // Generate sequence +1  sequence.push_back('1');  generateSequencesWithSum(n - 1 sumToString sequence  sumSoFar + 1);  sequence.erase(sequence.begin()); } // function to form permutations of the sequences void permuteSequences(vector<vector<string> > sumToString) {  // There are 2^n substring in this list of lists  for (int sumIndexArr = 0;  sumIndexArr < sumToString.size(); sumIndexArr++) {  // Append  for (int sequence1 = 0;  sequence1 < sumToString[sumIndexArr].size();  sequence1++) {  for (int sequence2 = 0;  sequence2  < sumToString[sumIndexArr].size();  sequence2++) {  if (sumIndexArr == sumToString.size() - 1  && sequence1  == sumToString[sumIndexArr]  .size()  - 1  && sequence2  == sumToString[sumIndexArr]  .size()  - 1) {  cout << '1111 ';  }  else {  cout << sumToString[sumIndexArr]  [sequence1]  + sumToString[sumIndexArr]  [sequence2]  << ' ';  }  }  }  } } // function that finds all the subsequences void findAllSequences(int n) {  vector<vector<string> > sumToString;  for (int i = 0; i < n + 1; i++) {  sumToString.push_back(  vector<string>()); // list of strings  // where index  // represents sum  }  generateSequencesWithSum(n sumToString  vector<string>() 0);  permuteSequences(sumToString); } // Driver Code int main() {  // Function Call  findAllSequences(2);  return 0; } // this code is contributed by phasing17 

// Java program to implement the approach import java.util.*; class GFG {  // function that finds all the subsequences  static void findAllSequences(int n)  {  ArrayList<ArrayList<String> > sumToString  = new ArrayList<ArrayList<String> >();  for (int i = 0; i < n + 1; i++) {  sumToString.add(  new ArrayList<String>()); // list of strings  // where index  // represents sum  }  generateSequencesWithSum(  n sumToString new ArrayList<String>() 0);  permuteSequences(sumToString);  }  static void generateSequencesWithSum(  int n ArrayList<ArrayList<String> > sumToString  ArrayList<String> sequence int sumSoFar)  {  // Base case if there are no more binary digits to  // include  if (n == 0) {  // add permutation to list of sequences with sum  // corresponding to index  String seq = '';  for (int i = 0; i < sequence.size(); i++) {  seq = seq + sequence.get(i);  }  ArrayList<String> x = sumToString.get(sumSoFar);  x.add(seq);  sumToString.set(sumSoFar x);  return;  }  // Generate sequence +0  sequence.add('0');  generateSequencesWithSum(n - 1 sumToString  sequence sumSoFar);  sequence.remove(0);  // Generate sequence +1  sequence.add('1');  generateSequencesWithSum(n - 1 sumToString  sequence sumSoFar + 1);  sequence.remove(0);  }  // function to form permutations of the sequences  static void permuteSequences(  ArrayList<ArrayList<String> > sumToString)  {  // There are 2^n substring in this list of lists  for (int sumIndexArr = 0;  sumIndexArr < sumToString.size();  sumIndexArr++) {  // Append  for (int sequence1 = 0;  sequence1  < sumToString.get(sumIndexArr).size();  sequence1++) {  for (int sequence2 = 0;  sequence2  < sumToString.get(sumIndexArr).size();  sequence2++) {  if (sumIndexArr  == sumToString.size() - 1  && sequence1  == sumToString  .get(sumIndexArr)  .size()  - 1  && sequence2  == sumToString  .get(sumIndexArr)  .size()  - 1) {  System.out.print('1111');  }  else {  System.out.println(  sumToString.get(sumIndexArr)  .get(sequence1)  + sumToString.get(sumIndexArr)  .get(sequence2));  }  }  }  }  }  // Driver Code  public static void main(String[] args)  {  // Function Call  findAllSequences(2);  }  // this code is contributed by phasing17 } 

def findAllSequences(n): sumToString = [[] for x in range(n+1)] # list of strings where index represents sum generateSequencesWithSum(n sumToString [] 0) permuteSequences(sumToString) def generateSequencesWithSum(n sumToString sequence sumSoFar): #Base case if there are no more binary digits to include if n == 0: sumToString[sumSoFar].append(''.join(sequence)) #add permutation to list of sequences with sum corresponding to index return #Generate sequence +0 sequence.append('0') generateSequencesWithSum(n-1 sumToString sequence sumSoFar) sequence.pop() #Generate sequence +1 sequence.append('1') generateSequencesWithSum(n-1 sumToString sequence sumSoFar+1) sequence.pop() def permuteSequences(sumToString): #There are 2^n substring in this list of lists for sumIndexArr in sumToString: # Append for sequence1 in sumIndexArr: for sequence2 in sumIndexArr: print(sequence1 + sequence2) findAllSequences(2) #Contribution by Xavier Jean Baptiste 

using System; using System.Collections.Generic; class GFG {  static void findAllSequences(int n)  {  List<List<string>> sumToString = new List<List<string>>();  for(int i = 0; i < n + 1; i++)  {  sumToString.Add(new List<string>()); // list of strings where index represents sum  }  generateSequencesWithSum(n sumToString new List<string>() 0);  permuteSequences(sumToString);  }  static void generateSequencesWithSum(int n List<List<string>> sumToString List<string> sequence int sumSoFar)  {  // Base case if there are no more binary digits to include  if(n == 0)  {  //add permutation to list of sequences with sum corresponding to index  string seq = '';  for(int i = 0; i < sequence.Count; i++)  {  seq = seq + sequence[i];  }  sumToString[sumSoFar].Add(seq);  return;  }  // Generate sequence +0  sequence.Add('0');  generateSequencesWithSum(n-1 sumToString sequence sumSoFar);  sequence.RemoveAt(0);  // Generate sequence +1  sequence.Add('1');  generateSequencesWithSum(n-1 sumToString sequence sumSoFar+1);  sequence.RemoveAt(0);  }  static void permuteSequences(List<List<string>> sumToString)  {  // There are 2^n substring in this list of lists  for(int sumIndexArr = 0; sumIndexArr < sumToString.Count; sumIndexArr++)  {  // Append  for(int sequence1 = 0; sequence1 < sumToString[sumIndexArr].Count; sequence1++)  {  for(int sequence2 = 0; sequence2 < sumToString[sumIndexArr].Count; sequence2++)  {  if(sumIndexArr == sumToString.Count-1 && sequence1 == sumToString[sumIndexArr].Count-1 && sequence2 == sumToString[sumIndexArr].Count-1)  {  Console.Write('1111');  }  else  {  Console.WriteLine(sumToString[sumIndexArr][sequence1] + sumToString[sumIndexArr][sequence2]);  }  }  }  }  }  static void Main() {  findAllSequences(2);  } } // This code is contributed by divyesh072019. 

<script>  function findAllSequences(n)  {  let sumToString = [];  for(let i = 0; i < n + 1; i++)  {  sumToString.push([]); // list of strings where index represents sum  }  generateSequencesWithSum(n sumToString [] 0);  permuteSequences(sumToString);  }    function generateSequencesWithSum(n sumToString sequence sumSoFar)  {  // Base case if there are no more binary digits to include  if(n == 0)  {  //add permutation to list of sequences with sum corresponding to index  sumToString[sumSoFar].push(sequence.join(''));  return;  }  // Generate sequence +0  sequence.push('0');  generateSequencesWithSum(n-1 sumToString sequence sumSoFar);  sequence.shift();  // Generate sequence +1  sequence.push('1');  generateSequencesWithSum(n-1 sumToString sequence sumSoFar+1);  sequence.shift();  }    function permuteSequences(sumToString)  {  // There are 2^n substring in this list of lists  for(let sumIndexArr = 0; sumIndexArr < sumToString.length; sumIndexArr++)  {  // Append  for(let sequence1 = 0; sequence1 < sumToString[sumIndexArr].length; sequence1++)  {  for(let sequence2 = 0; sequence2 < sumToString[sumIndexArr].length; sequence2++)   {  if(sumIndexArr == sumToString.length-1 && sequence1 == sumToString[sumIndexArr].length-1 && sequence2 == sumToString[sumIndexArr].length-1)  {  document.write('1111');  }  else  {  document.write(sumToString[sumIndexArr][sequence1] + sumToString[sumIndexArr][sequence2] + '
');  }  }  }  }  }    findAllSequences(2);    // This code is contributed by decode2207. </script> 

#include   using namespace std; class FirstHalf {  public:  string data;  int sum;  FirstHalf(string data int sum) {  this->data = data;  this->sum = sum;  } }; // MAP: Key -> sum of bits; Value -> All possible permutation with respective sum map<int vector<string>> mp; // first N-half bits vector<FirstHalf> firstHalf; // function to find sum of the bits from a String int sumOfString(string s) {  int sum = 0;  // ex: converts '1' to 1 -> (ASCII('1') - ASCII('0') = 1)  for(auto c: s) {  sum += (c - '0');  }  return sum; } void perm(string p char* bin int level int n)  {  // p: processed string(processed permutation at current level)  // bin: {'0' '1'}  // l: current level of recursion tree (leaf/solution level = 0)  // n: total levels  if(level == 0)   {  // at solution level find sum of the current permutation  int sum = sumOfString(p);  // store current permutation to firstHalf list  firstHalf.push_back(FirstHalf(p sum));  // put current permutation to its respective sum value  mp[sum].push_back(p);  return;  }  // generate calls for permutation  // working: first solution with all 0s   // then replacing last 0 with 1 and so on...  for(int i = 0; i < n; i++) {  char c = bin[i];  perm(p+c bin level-1 n);  } } void result() {  int i = 0;  for(auto first: firstHalf)  {  // for each firstHalf string  // find sum of the bits of current string  int sum = first.sum;  // retrieve respective secondHalf from map based on sum key  vector<string> secondHalf = mp[sum];  for(auto second: secondHalf)  {  // append first and second half and print  cout << first.data + second << ' ';  // after every 6 solution line is changed in output  // only for formatting below lines could be removed  i++;  if(i % 6 == 0)  cout << endl;  }  } } int main(){  char up[2] = {'0' '1'};  int n = 2;  string x = '';  perm(x up n n);  result();  return 0; } // This code is contributed by Nidhi goel.  

import java.util.*; class GFG {  static class FirstHalf {  String data;  int sum;  FirstHalf(String data int sum) {  this.data = data;  this.sum = sum;  }  }  //MAP: Key -> sum of bits; Value -> All possible permutation with respective sum  static Map<Integer ArrayList<String>> map = new HashMap<>();  //first N-half bits  static List<FirstHalf> firstHalf = new ArrayList<>();  //function to find sum of the bits from a String  public static int sumOfString(String s) {  int sum = 0;  //ex: converts '1' to 1 -> (ASCII('1') - ASCII('0') = 1)  for(char c: s.toCharArray()) {  sum += c - '0';  }  return sum;  }  public static void perm(String p char[] bin int level int n) {  //p: processed string(processed permutation at current level)  //bin: {'0' '1'}  //l: current level of recursion tree (leaf/solution level = 0)  //n: total levels  if(level == 0) {  //at solution level find sum of the current permutation  int sum = sumOfString(p);  //store current permutation to firstHalf list  firstHalf.add(new FirstHalf(p sum));  //put current permutation to its respective sum value  map.putIfAbsent(sum new ArrayList<String>());  map.get(sum).add(p);  return;  }  //generate calls for permutation  //working: first solution with all 0s then replacing last 0 with 1 and so on...  for(char c: bin) {  perm(p+c bin level-1 n);  }  }  public static void result() {  int i = 0;  for(FirstHalf first: firstHalf) {  //for each firstHalf string  //find sum of the bits of current string  int sum = first.sum;  //retrieve respective secondHalf from map based on sum key  ArrayList<String> secondHalf = map.get(sum);  for(String second: secondHalf) {  //append first and second half and print  System.out.print(first.data+second+' ');  //after every 6 solution line is changed in output  //only for formatting below lines could be removed  i++;  if(i % 6 == 0)  System.out.println();  }  }  }  public static void main(String[] args) {  char[] up = {'0' '1'};  int n = 2;  perm('' up n n);  result();  } } //Code contributed by Animesh Singh 

# Python code implementation class FirstHalf: def __init__(self data sum): self.data = data self.sum = sum # MAP: Key -> sum of bits; Value -> All possible permutation with respective sum map = {} # first N-half bits firstHalf = [] # function to find sum of the bits from a String def sumOfString(s): sum = 0 # ex: converts '1' to 1 -> (ASCII('1') - ASCII('0') = 1) for i in range(len(s)): sum += ord(s[i]) - ord('0') return sum def perm(p bin level n): # p: processed string(processed permutation at current level) # bin: ['0' '1'] # l: current level of recursion tree (leaf/solution level = 0) # n: total levels if level == 0: # at solution level find sum of the current permutation sum = sumOfString(p) # store current permutation to firstHalf list firstHalf.append(FirstHalf(p sum)) # put current permutation to its respective sum value if sum not in map: map[sum] = [] map[sum].append(p) return # generate calls for permutation # working: first solution with all 0s then replacing last 0 with 1 and so on... for i in range(len(bin)): perm(p+bin[i] bin level-1 n) def result(): i = 0 for j in range(len(firstHalf)): # for each firstHalf string # find sum of the bits of current string sum = firstHalf[j].sum # retrieve respective secondHalf from map based on sum key secondHalf = map[sum] for k in range(len(secondHalf)): # append first and second half and print print(firstHalf[j].data + secondHalf[k] + ' ' end='') # after every 6 solution line is changed in output # only for formatting below lines could be removed i = i + 1 if(i % 6 == 0): print('n') up = ['0' '1'] n = 2 perm('' up n n) result() # The code is contributed by Nidhi goel. 

using System; using System.Collections.Generic; class FirstHalf {  public string data;  public int sum;  public FirstHalf(string data int sum) {  this.data = data;  this.sum = sum;  } } class Gfg {    // MAP: Key -> sum of bits; Value -> All possible permutation with respective sum  static Dictionary<int List<string>> mp = new Dictionary<int List<string>>();  // first N-half bits  static List<FirstHalf> firstHalf = new List<FirstHalf>();  // function to find sum of the bits from a String  static int sumOfString(string s) {  int sum = 0;  // ex: converts '1' to 1 -> (ASCII('1') - ASCII('0') = 1)  foreach (char c in s) {  sum += (c - '0');  }  return sum;  }  static void perm(string p char[] bin int level int n) {  // p: processed string(processed permutation at current level)  // bin: {'0' '1'}  // l: current level of recursion tree (leaf/solution level = 0)  // n: total levels  if (level == 0) {  // at solution level find sum of the current permutation  int sum = sumOfString(p);  // store current permutation to firstHalf list  firstHalf.Add(new FirstHalf(p sum));  // put current permutation to its respective sum value  if (mp.ContainsKey(sum)) {  mp[sum].Add(p);  } else {  mp.Add(sum new List<string> { p });  }  return;  }  // generate calls for permutation  // working: first solution with all 0s   // then replacing last 0 with 1 and so on...  for (int i = 0; i < n; i++) {  char c = bin[i];  perm(p + c bin level - 1 n);  }  }  static void result() {  int i = 0;  foreach (FirstHalf first in firstHalf) {  // for each firstHalf string  // find sum of the bits of current string  int sum = first.sum;  // retrieve respective secondHalf from map based on sum key  List<string> secondHalf = mp[sum];  foreach (string second in secondHalf) {  // append first and second half and print  Console.Write(first.data + second + ' ');  // after every 6 solution line is changed in output  // only for formatting below lines could be removed  i++;  if (i % 6 == 0)  Console.WriteLine();  }  }  }  static void Main(string[] args) {  char[] up = { '0' '1' };  int n = 2;  string x = '';  perm(x up n n);  result();  } } 

class FirstHalf {  constructor(data sum) {  this.data = data;  this.sum = sum;  } } // MAP: Key -> sum of bits; Value -> All possible permutation with respective sum const map = new Map(); // first N-half bits const firstHalf = []; // function to find sum of the bits from a String function sumOfString(s) {  let sum = 0;  //ex: converts '1' to 1 -> (ASCII('1') - ASCII('0') = 1)  for(let i = 0; i < s.length; i++) {  sum += s.charCodeAt(i) - '0'.charCodeAt(0);  }  return sum; } function perm(p bin level n) {  // p: processed string(processed permutation at current level)  // bin: ['0' '1']  // l: current level of recursion tree (leaf/solution level = 0)  // n: total levels  if(level == 0)  {    // at solution level find sum of the current permutation  let sum = sumOfString(p);    // store current permutation to firstHalf list  firstHalf.push(new FirstHalf(p sum));    // put current permutation to its respective sum value  if(!map.has(sum)) map.set(sum []);  map.get(sum).push(p);  return;  }    // generate calls for permutation  // working: first solution with all 0s then replacing last 0 with 1 and so on...  for(let i = 0; i < bin.length; i++) {  perm(p+bin[i] bin level-1 n);  } } function result() {  let i = 0;  for(let j = 0; j < firstHalf.length; j++)  {    // for each firstHalf string  // find sum of the bits of current string  let sum = firstHalf[j].sum;    // retrieve respective secondHalf from map based on sum key  let secondHalf = map.get(sum);  for(let k = 0; k < secondHalf.length; k++)   {    // append first and second half and print  process.stdout.write(firstHalf[j].data + secondHalf[k] + ' ');    // after every 6 solution line is changed in output  // only for formatting below lines could be removed  i++;  if(i % 6 == 0)  process.stdout.write('n');  }  } } const up = ['0' '1']; const n = 2; perm('' up n n); result();