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

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

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