(UVA) 10008 - What's Cryptanalysis? - Solução

import java.io.*;
import java.util.*;
import java.lang.Math;

class Main {
    public static void main(String[] args) throws NumberFormatException, IOException {
        Main processando = new Main();
        processando.takeInput();
       
        System.exit(0);
    }
   
    void takeInput() throws NumberFormatException, IOException {
        String line = "";
        String entrada = "";
        StringTokenizer tokenizer = null;
       
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
       
        line = br.readLine();
        tokenizer = new StringTokenizer(line);
        Integer n = Integer.parseInt(tokenizer.nextToken());
        Integer contador = 0;
       
        ArrayList<Character> vetor = new ArrayList<Character>();
       
        Map<Character, Integer> letras = new TreeMap<Character, Integer>();
       
        Integer i = 0;
        Integer index = 0;
        Integer tamanho = 0;
       
        // passa o que lê para um arraylist
        while (contador < n) { 
            entrada = br.readLine();
           
            tamanho = entrada.length();
                       
            for (i = 0; i < tamanho; i++) {
                if (Character.isLetter(entrada.charAt(i)) == true) {
                    vetor.add(index, Character.toUpperCase(entrada.charAt(i)));
                    index++;
                }
            }
            contador++;
        }
       
        // passa o que foi lido para um treemap   
        tamanho = vetor.size();
       
        for (i = 0; i < tamanho; i++) {
            Integer qte = letras.get(vetor.get(i));
           
            if (qte == null) {
                qte = 0;
            }
           
            qte++;
           
            letras.put(vetor.get(i), qte);

        }
                       
        // Ordena pelo value do Map
        Map<Character, Integer> sortedLetras = sortByComparator(letras);
       
        // Imprime
        tamanho = sortedLetras.size();
       
        ArrayList<Character> key = new ArrayList<Character>();
        ArrayList<Integer> value = new ArrayList<Integer>();
       
        index = 0;       
        for (Map.Entry<Character, Integer> chave: sortedLetras.entrySet()) {
            key.add(index, chave.getKey());
            value.add(index, chave.getValue());
            index++;
        }
       
        index = tamanho - 1;
        Integer vezes = 0;
        boolean entrou = false;
       
        while (tamanho > 0) {
            i = tamanho - 1;
            while (i-1 >= 0 && value.get(i) == value.get(i-1)) {
                index = i - 1;
                i--;
                entrou = true;
            }
            vezes = 0;
            for (int j = index; j < tamanho; j++) {
                System.out.println(key.get(j) + " " + value.get(j));
                if (entrou == false) {
                    index--; // só se não foi em cima
                }
                vezes++;
            }
            entrou = false;
            tamanho = tamanho - vezes;
        }       

       
        return;
    }
   
    // ordena pelo value do map
    private static Map sortByComparator(Map unsortMap) {

        List list = new LinkedList(unsortMap.entrySet());

        // sort list based on comparator
        Collections.sort(list, new Comparator() {
            public int compare(Object o1, Object o2) {
                return ((Comparable) ((Map.Entry) (o1)).getValue())
                                       .compareTo(((Map.Entry) (o2)).getValue());
            }
        });

        // put sorted list into map again
                //LinkedHashMap make sure order in which keys were inserted
        Map sortedMap = new LinkedHashMap();
        for (Iterator it = list.iterator(); it.hasNext();) {
            Map.Entry entry = (Map.Entry) it.next();
            sortedMap.put(entry.getKey(), entry.getValue());
        }
        return sortedMap;
    }

}