SubString Anagrams

import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.*;
import java.util.regex.*;
import java.util.stream.*;
import static java.util.stream.Collectors.joining;
import static java.util.stream.Collectors.toList;

class Result {

    /*
     * Complete the 'sherlockAndAnagrams' function below.
     *
     * The function is expected to return an INTEGER.
     * The function accepts STRING s as parameter.
     */

    //#2
    public static int sherlockAndAnagrams(String s) {
    // Write your code here
    int result = 0;

    char[] letters = s.toCharArray();

    List<List<List<Character>>> subStrings = new ArrayList<>();

    for (int i = 0 ; i < letters.length; i++) {
        List<Character> subString = new ArrayList<>();
        List<List<Character>> letter = new ArrayList<>();
        subString.add(letters[i]);


        for (int j = i; j < letters.length; j++) {
            letter.add(new ArrayList<>(subString));
        }

        subStrings.add(letter);

        for (int j = 0 ; j < i ; j++) {
            for (int k = 0 ; k < letters.length - i; k++) {
                subStrings.get(j).get(k).add(letters[i]);
            }
        }
    }

    /*for (List<List<Character>> list : subStrings) {
        for (List<Character> list1 : list) {
            System.out.println(list1);
        }
    }*/

    /*for (int i = 0; i < subStrings.size(); i++) {
        for (int j = 0; j < subStrings.get(i).size(); j++) {
            System.out.println(subStrings.get(i).get(j));
        }
    }*/

    for (int i = 0; i < subStrings.size()-1; i++) {
        for (int j = subStrings.get(i).size() -1; j > 0 ; j--) {
            if (subStrings.get(i).get(j) == null) {
                continue;
            }
            int frequency = 1;
            for (int k = i + 1 ; k < j + 1; k++) {
                /*System.out.println(subStrings.get(i).get(j));
                System.out.println(subStrings.get(k).get(j - k + i));
                System.out.println("");*/

                if (subStrings.get(k).get(j - k + i) == null) {
                    continue;
                }
                if (subStrings.get(i).get(j).containsAll(subStrings.get(k).get(j - k + i))
                && subStrings.get(k).get(j - k + i).containsAll(subStrings.get(i).get(j))) {
                    frequency++;
                    subStrings.get(k).set(j - k + i, null);



                }
            }
            System.out.println(frequency);
            result += count(frequency);

        }
    }


    return result;


    }

    public static int count(int frequency) {
        int result = 0;
        for (int i = 0; i < frequency ; i++) {
            result += i;
        }

        return result;
    }

    //#1
    public static int sherlockAndAnagrams(String s) {
    // Write your code here
    int result = 0;

    int length = s.length();
    int maxSubStringLength = length / 2;

    List<List<Character>> subStrings = new ArrayList<>();

    for (int i = 0 ; i < length ; i++) {
        for (int j = i + 1; j <= length ; j++) {
            String subString = s.substring(i, j);
            /*if (subString.length() > maxSubStringLength) {
                break;
            }*/

            List<Character> chars = subString
                .chars()
                .mapToObj(e -> (char)e)
                .sorted()
                .collect(Collectors.toList());

            subStrings.add(chars);
        }
    }

    /*for (List<Character> list : subStrings) {
        System.out.println(list);
    }*/

    List<List<Character>> checked = new ArrayList<>();


    while (subStrings.size() > 0) {
        checked.add(subStrings.get(0));

        int frequency = Collections.frequency(subStrings, subStrings.get(0));

        result += count(frequency);

        subStrings.removeAll(checked);
    }


    return result;


    }

    public static int count(int frequency) {
        int result = 0;
        for (int i = 0; i < frequency ; i++) {
            result += i;
        }

        return result;
    }

}

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(System.getenv("OUTPUT_PATH")));

        int q = Integer.parseInt(bufferedReader.readLine().trim());

        IntStream.range(0, q).forEach(qItr -> {
            try {
                String s = bufferedReader.readLine();

                int result = Result.sherlockAndAnagrams(s);

                bufferedWriter.write(String.valueOf(result));
                bufferedWriter.newLine();
            } catch (IOException ex) {
                throw new RuntimeException(ex);
            }
        });

        bufferedReader.close();
        bufferedWriter.close();
    }
}