[НП] - Лабораториски вежби

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

class Student{
    private String index;
    private List<Integer> labPoints;

    public Student(String index, List<Integer> labPoints) {
        this.index = index;
        this.labPoints = labPoints;
    }

    public double getAverage(){
        return labPoints.stream().mapToDouble(labPoints -> labPoints).sum() / 10;
    }

    public String getIndex() {
        return index;
    }

    public boolean getSignature(){
        return labPoints.size() >= 8;
    }

    @Override
    public String toString() {
        return String.format("%s %s %.2f", index, getSignature()? "YES":"NO", getAverage());
    }
}

class LabExercises{
    Set<Student> students;

    public LabExercises() {
        this.students = new HashSet<>();
    }

    public void addStudent(Student student){
        students.add(student);
    }

    public void printByAveragePoints(boolean ascending, int n){
        Comparator<Student> ascendingComparator = Comparator.comparing(Student::getAverage).thenComparing(Student::getIndex);
        Comparator<Student> descendingComparator = Comparator.comparing(Student::getAverage).thenComparing(Student::getIndex).reversed();

        Comparator<Student> comparator = ascending ? ascendingComparator : descendingComparator;

        students.stream().sorted(comparator).limit(n).forEach(System.out::println);
    }

    public List<Student> failedStudents(){
        return students.stream()
                .filter(student -> !student.getSignature())
                .sorted(Comparator.comparing(Student::getIndex).thenComparing(Student::getAverage))
                .collect(Collectors.toList());
    }

    public Map<Integer, Double> getStatisticsByYear(){
        Map<Integer, Double> sum = new TreeMap<>(Integer::compareTo);
        Map<Integer, Integer> howMany = new TreeMap<>(Integer::compareTo);

        students.stream()
                .filter(Student::getSignature)
                .forEach(student -> {
                    int year = 20 - Integer.parseInt(student.getIndex().substring(0,2));
                    sum.computeIfAbsent(year, (k) -> sum.put(year,0.0));
                    sum.put(year, sum.get(year)+student.getAverage());

                    howMany.computeIfAbsent(year, (k) -> howMany.put(year,0));
                    howMany.put(year, howMany.get(year)+1);
                });

        Map<Integer, Double> result = new TreeMap<>(Integer::compareTo);
        sum.keySet()
                .forEach(year -> {
                    result.put(year, sum.get(year)/howMany.get(year));
                });
        return result;
    }
}

public class LabExercisesTest {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        LabExercises labExercises = new LabExercises();
        while (sc.hasNextLine()) {
            String input = sc.nextLine();
            String[] parts = input.split("\\s+");
            String index = parts[0];
            List<Integer> points = Arrays.stream(parts).skip(1)
                    .mapToInt(Integer::parseInt)
                    .boxed()
                    .collect(Collectors.toList());

            labExercises.addStudent(new Student(index, points));
        }

        System.out.println("===printByAveragePoints (ascending)===");
        labExercises.printByAveragePoints(true, 100);
        System.out.println("===printByAveragePoints (descending)===");
        labExercises.printByAveragePoints(false, 100);
        System.out.println("===failed students===");
        labExercises.failedStudents().forEach(System.out::println);
        System.out.println("===statistics by year");
        labExercises.getStatisticsByYear().entrySet().stream()
                .map(entry -> String.format("%d : %.2f", entry.getKey(), entry.getValue()))
                .forEach(System.out::println);

    }
}