JustCount

import java.util.*;
import java.util.stream.Collectors;

public class SecondTry {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine();
        splitString(input);
    }

    public static class result {
        int max;
        char aChar;

        public result(int max, char aChar) {
            this.max = max;
            this.aChar = aChar;
        }
    }

    static void splitString(String str) {
        StringBuilder alphaLow = new StringBuilder(),
                alphaHigh = new StringBuilder(),
                special = new StringBuilder();

        for (int i = 0; i < str.length(); i++) {
            if (Character.isAlphabetic(str.charAt(i))) {
                if (Character.isLowerCase(str.charAt(i))) {
                    alphaLow.append(str.charAt(i));
                } else if (Character.isUpperCase(str.charAt(i))) {
                    alphaHigh.append(str.charAt(i));
                }
            } else
                special.append(str.charAt(i));
        }
        String one = alphaLow.toString();
        result resultLow = printMaxOccurringChar(one);
        String two = alphaHigh.toString();
        result resultHigh = printMaxOccurringChar(two);
        String three = special.toString();
        result resultSpecial = printMaxOccurringChar(three);

        result[] results = {resultLow, resultHigh, resultSpecial};

        List<result> newList = Arrays.stream(results).sorted(Comparator.comparing(result -> result.max))
                .collect(Collectors.toList());

        Collections.reverse(newList);

        for (result result : newList) {
            System.out.printf("%c %d", result.aChar, result.max);
            System.out.println();
        }
    }

    public static result printMaxOccurringChar(String inputString) {

        HashMap<Character, Integer> charCountMap = new HashMap<>();

        char[] charArray = inputString.toCharArray();

        for (char c : charArray) {
            if (charCountMap.containsKey(c)) {
                charCountMap.put(c, charCountMap.get(c) + 1);
            } else {
                charCountMap.put(c, 1);
            }
        }

        Set<Map.Entry<Character, Integer>> entrySet = charCountMap.entrySet();

        int maxCount = 0;

        char maxChar = 0;

        for (Map.Entry<Character, Integer> entry : entrySet) {
            if (entry.getValue() > maxCount) {
                maxCount = entry.getValue();

                maxChar = entry.getKey();
            }
        }
        return new result(maxCount, maxChar);
    }
}