Highest Frequency Letters

Given a list of strings, output the most frequent characters that are in the same group as the letter. For example, for string "abc", a, b,c are in the same group. "bcd" are in the same group. For a: b,c . for b: c as c occured in two groups with letter b. duplicates are not considered. i.e "aabc" is the same as "abc"

Example

input: a list of strings { "abc", "bcd", "def"}.

output: a: b, c

b: c

c: b

d: b, c, e, f

e: d, f

 public class Test {
     public Map<Character, List<Character>> approach1(List<String> strs) {
         int[] max = new int[];
         int[][] cnt = new int[][];

         for (int wordIdx = ; wordIdx < strs.size(); ++wordIdx) {
             String word = strs.get(wordIdx); // for each word
             boolean[] charExist = new boolean[];
             for (char ch : word.toCharArray()) {
                 charExist[ch - 'a'] = true;
             }
             // for each combination of a-z
             for (int i = ; i < ; ++i) {
                 for (int j = ; j < i; ++j) {
                     if (charExist[i] && charExist[j]) {
                         ++cnt[i][j];
                         ++cnt[j][i];
                         max[i] = Math.max(max[i], cnt[i][j]);
                         max[j] = Math.max(max[j], cnt[j][i]);
                         assert (cnt[i][j] == cnt[j][i]);
                     }
                 }
             }
         }
         Map<Character, List<Character>> res = new HashMap<>();
         for (int charId = ; charId < ; ++charId) {
             if (max[charId] != ) {
                 List<Character> charList = new ArrayList<>();
                 for (int j = ; j < ; ++j) {
                     if (cnt[charId][j] == max[charId]) {
                         charList.add((char) ('a' + j));
                     }
                 }
                 res.put((char) ('a' + charId), charList);
             }
         }
         return res;
     }

     public Map<Character, List<Character>> approach2(List<String> strs) {
         Map<Character, Map<Character, Integer>> mapping = new HashMap<>();
         for (int wordIdx = ; wordIdx < strs.size(); ++wordIdx) {
             process(strs.get(wordIdx), mapping);
         }

         Map<Character, List<Character>> res = new HashMap<>();
         mapping.entrySet().stream().forEach(entry -> {
             res.put(entry.getKey(), highestFrequentCharacters(entry.getValue()));
         });
         return res;
     }

     private List<Character> highestFrequentCharacters(Map<Character, Integer> map) {
         List<Character> list = new ArrayList<>();
         int highestCount = map.values().stream().mapToInt(count -> count.intValue()).max().getAsInt();
         for (Map.Entry<Character, Integer> entry : map.entrySet()) {
             if (entry.getValue() == highestCount) {
                 list.add(entry.getKey());
             }
         }
         return list;
     }

     private void process(String word, Map<Character, Map<Character, Integer>> mapping) {
         Character[] uniqueChars = uniqueCharacters(word);
         for (int i = ; i < uniqueChars.length; i++) {
             for (int j = i + ; j < uniqueChars.length; j++) {
                 updateMap(mapping, uniqueChars[i], uniqueChars[j]);
                 updateMap(mapping, uniqueChars[j], uniqueChars[i]);
             }
         }
     }

     private void updateMap(Map<Character, Map<Character, Integer>> mapping, Character firstLetter,
             Character secondLetter) {
         Map<Character, Integer> letterToCountMap = mapping.getOrDefault(firstLetter, new HashMap<>());
         Integer count = letterToCountMap.getOrDefault(secondLetter, ) + ;
         letterToCountMap.put(secondLetter, count);
         mapping.put(firstLetter, letterToCountMap);
     }

     private Character[] uniqueCharacters(String str) {
         return str.chars().mapToObj(ch -> (char) ch).distinct().toArray(Character[]::new);
     }
 }