04. Hornet Armada - 60/100

import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class HornetArmada {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = Integer.parseInt(scanner.nextLine());

        Map<String, Integer> nameActivity = new LinkedHashMap<>();
        Map<String, Map<String, Long>> nameTypeCount = new LinkedHashMap<>();

        for (int i = 0; i < n; i++) {
            String info = scanner.nextLine();

            String regex = "^(?<activity>\\d+) = (?<name>[^=->: ]+) -> (?<type>[^=->: ]+):(?<count>\\d+)$";
            Pattern pattern = Pattern.compile(regex);
            Matcher matcher = pattern.matcher(info);

            if (matcher.find()) {
                int activity = Integer.parseInt(info.split(" = ")[0]);
                String name = matcher.group("name");
                String type = matcher.group("type");
                long count = Long.parseLong(info.split(":")[1]);

                if (!nameActivity.containsKey(name)) {
                    nameActivity.put(name, activity);
                    nameTypeCount.put(name, new LinkedHashMap<>());
                    nameTypeCount.get(name).put(type, count);
                } else {
                    if (activity > nameActivity.get(name)) {
                        nameActivity.put(name, activity);
                    }
                    if (!nameTypeCount.get(name).containsKey(type)) {
                        nameTypeCount.get(name).put(type, count);
                    } else {
                        nameTypeCount.get(name).put(type, count + nameTypeCount.get(name).get(type));
                    }
                }
            }
        }

        String line = scanner.nextLine();

        if (line.contains("\\")) {
            int activity = Integer.parseInt(line.split("\\\\")[0]);
            String soldierType = line.split("\\\\")[1];

            if (!nameTypeCount.isEmpty()) {
                nameTypeCount.entrySet()
                        .stream()
                        .filter(e -> {
                            return nameActivity.get(e.getKey()) < activity;
                        })
                        .sorted((f, s) -> {
                            return (int) (s.getValue().get(soldierType) - f.getValue().get(soldierType));
                        })
                        .forEach(e -> {
                            System.out.printf("%s -> %d%n", e.getKey(), e.getValue().get(soldierType));
                        });
            }

        } else {
            String soldierType = line;

            if (!nameActivity.isEmpty()) {
                nameActivity.entrySet()
                        .stream()
                        .filter(e -> {
                            return nameTypeCount.get(e.getKey()).containsKey(soldierType);
                        })
                        .sorted((f, s) -> {
                            return s.getValue() - f.getValue();
                        })
                        .forEach(e -> {
                            System.out.printf("%d : %s%n", e.getValue(), e.getKey());
                        });
            }
        }

    }
}