[НП] Студентски досиеа

/*
Студентски досиеа (60 поени)
Да се имплементира класа StudentRecords која ќе чита од влезен тек (стандарден влез, датотека, ...) податоци за студентски досиеа. Податоците содржат (код - единствен стринг), насока (стринг од 3 букви) и низа со оценки (цели броеви од 6 - 10). Сите податоци се разделени со едно празно место.

Пример за форматот на податоците:
ioqmx7 MT 10 8 10 8 10 7 6 9 9 9 6 8 6 6 9 9 8


Ваша задача е да ги имплементирате методите:

StudentRecords() - default конструктор

int readRecords(InputStream inputStream) - метод за читање на податоците кој враќа вкупно прочитани записи

void writeTable(OutputStream outputStream) - метод кој ги печати сите записите за сите студенти групирани по насока (најпрво се печати името на насоката), а потоа се печатат сите записи за студентите од таа насока сортирани според просекот во опаѓачки редослед (ако имаат ист просек според кодот лексикографски) во формат kod prosek, каде што просекот е децимален број заокружен на две децимали. Пример jeovz8 8.47. Насоките се сортирани лексикографски. Комплексноста на методот да не надминува O(N) во однос на бројот на записи.

void writeDistribution(OutputStream outputStream) - метод за печатење на дистрибуцијата на бројот на оценки по насока, притоа насоките се сортирани по бројот на десетки во растечки редослед (прва е насоката со најмногу оценка десет). Дистрибуцијата на оценки се печати во следниот формат:

NASOKA
[оценка со 2 места порамнети во десно] | [по еден знак * на секои 10 оценки] ([вкупно оценки])

Пример:
KNI
 6 | ***********(103)
 7 | ******************(173)
 8 | *******************(184)
 9 | *****************(161)
10 | **************(138)
Комплексноста на овој метод да не надминува O(N∗M∗log2(M)) за N записи и M насоки
*/


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

/**
 * January 2016 Exam problem 1
 */
public class StudentRecordsTest {
    public static void main(String[] args) {
        System.out.println("=== READING RECORDS ===");
        StudentRecords studentRecords = new StudentRecords();
        int total = studentRecords.readRecords(System.in);
        System.out.printf("Total records: %d\n", total);
        System.out.println("=== WRITING TABLE ===");
        studentRecords.writeTable(System.out);
        System.out.println("=== WRITING DISTRIBUTION ===");
        studentRecords.writeDistribution(System.out);
    }
}

class Student {
    private String code;
    private List<Integer> grades;

    public Student(String code, List<Integer> grades) {
        this.code = code;
        this.grades = new ArrayList<>(grades.size());
        this.grades.addAll(grades);
    }

    public String getCode() {
        return code;
    }

    public double calculateAverage() {
        return grades.stream().mapToInt((g) -> g).average().orElse(0);
    }

    public Integer countGrades(int grade) {
        return Math.toIntExact(grades.stream()
                .filter((g) -> g == grade)
                .count());
    }

    @Override
    public String toString() {
        return String.format("%s %.2f", code, calculateAverage());
    }
}

class Program {
    private String name;
    private TreeSet<Student> students;

    public Program(String name) {
        this.name = name;
        this.students = new TreeSet<>(
                Comparator.comparingDouble(Student::calculateAverage)
                .reversed()
                .thenComparing(Student::getCode));
    }

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

    public String printAverage() {
        StringBuilder sb = new StringBuilder();
        sb.append(name).append("\n");
        students.forEach((s) -> sb.append(s).append("\n"));
        return sb.toString();
    }

    public Integer getGradeDistribution(int grade) {
        return students.stream()
                .mapToInt((s) -> s.countGrades(grade))
                .sum();
    }

    public String printGradeDistribution(int grade) {
        StringBuilder sb = new StringBuilder();
        int grades = getGradeDistribution(grade);
        int asterisks = (int)Math.ceil((double)grades/10);

        for(int i=0; i<asterisks; i++)
            sb.append("*");

        sb.append("(").append(grades).append(")");
        return sb.toString();
    }

    public String getName() {
        return name;
    }
}

class StudentRecords {
    private TreeMap<String, Program> records;

    public StudentRecords() {
        this.records = new TreeMap<>();
    }

    int readRecords(InputStream inputStream) {
        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String line;
        int readRecords = 0;

        try {
            while((line = br.readLine()) != null) {
                if (line.equals("KRAJ")) break;
                String[] parts = line.split("\\s+");

                List<Integer> grades = IntStream.range(2, parts.length)
                        .mapToObj((i) -> Integer.parseInt(parts[i]))
                        .collect(Collectors.toList());

                Student newStudent = new Student(parts[0], grades);
                Program studentProgram =
                        records.computeIfAbsent(parts[1], (sr) -> new Program(parts[1]));
                studentProgram.addStudent(newStudent);

                readRecords++;
            }
            br.close();
        } catch(IOException e) {
            e.printStackTrace();
        }
        return readRecords;
    }

    void writeTable(OutputStream outputStream) {
        PrintWriter pw = new PrintWriter(outputStream);
        records.values().forEach((p) -> pw.println(p.printAverage()));

        //O(n) -> gi izminuva site studenti ednas
        // taka sto nasoki*studenti = N (site studenti)

        pw.flush();
   }

    void writeDistribution(OutputStream outputStream) {
        PrintWriter pw = new PrintWriter(outputStream);

        records.values().stream()
                .sorted((p1, p2) -> -p1.getGradeDistribution(10).compareTo(p2.getGradeDistribution(10)))
                .forEach((p) -> {
                    pw.println(p.getName());
                    IntStream.range(6, 11)
                            .forEach((i) -> {
                                pw.printf("%2d | %s\n", i, p.printGradeDistribution(i));
                            });
                });

        //Sortiranje logM na nasokite
        //Izminuvanje na sekoj student po ednas (ne e M*N zatoa sto vo edna nasoka imam nekolku studenti, ne site)
        // Kompleksnost: O(N*Log2M)

        pw.flush();
        pw.close();
    }
}