Kont 2016

private Grade(char grade) { ... }
public static Grade A = new Grade('A'), B = new Grade('B'), ... , F = new
Grade('F');

private int year;
private char semester; // F(all) eller S(pring)

public int getYear() {
   return year;
}

public char getSemester() {
   return semester;
}


public String getTime() {
   return String.valueOf(getSemester()) + year;
}

public static void checkTime(String time) throws IllegalArgumentException {
   char c0 = Character.toUpperCase(time.charAt(0));
   if (c0 != 'S' && c0 != 'F') {
      throw new IllegalArgumentException("Semester must be either F(all) or S(pring)");
   }
   Integer.valueOf(time.substring(1));
}

public void setTime(String time) {
   checkTime(time);
   int year = Integer.valueOf(time.substring(1));
   if (year < 100) {
      year = (year < 50 ? 2000 : 1900) + year;
   }
   this.semester = Character.toUpperCase(time.charAt(0));
   this.year = year;
}

public class Course implements Comparable<Course> {
   // Compares based on the time given, earlier means smaller.
   @Override
   public int compareTo(Course other) {
      if (year != other.year) {
         return year - other.year;
      }
      return (other.semester - semester);
   }
}

private final Course course;
private char grade;


public Exam(Course course, char grade) {
   this.course = course;
   grade = Character.toUpperCase(grade);
   if ("ABCDEF".indexOf(grade) < 0) {
      throw new IllegalArgumentException("Result must be one of the characters A-F");
   }
   this.grade = grade;
}

public boolean isPass() {
   return grade != 'F';
}

public class Exam implements Comparable<Exam> {


   @Override
   public int compareTo(Exam other) {
      return course.compareTo(other.getCourse());
   }
}

public class ExamComparator implements Comparator<Exam> {


   @Override
   public int compare(Exam exam1, Exam exam2) {
      return exam1.getGrade() - exam2.getGrade();
   }
}

private final String name;
 
public Person(String name) {
   this.name = name;
}


public String getName() {
   return name;
}

private Collection<Course> courses = new ArrayList<Course>();
      
public boolean addCourse(Course course) {
   for (Course existing : courses) {
      if (course.getCode().equals(existing.getCode()) && course.getTime().equals(existing.getTime())) {
         return false;
      }
   }
   courses.add(course);
   return true;
}
      
public boolean hasCourse(String code) {
   for (Course course : courses) {
      if (code.equals(course.getCode())) {
         return true;
      }
   }
   return false;
}

private Collection<Exam> exams = new ArrayList<Exam>();
 
public Exam addExam(Course course, char grade) {
   if (courses.contains(course)) {
      for (Exam exam : exams) {
         if (exam.getCourse() == course && exam.isPass()) {
            return null;
         }
      }
      Exam exam = new Exam(course, grade);
      exams.add(exam);
      return exam;
   }
   return null;
}
 
public Exam getLastExam(String code) {
   Exam lastExam = null;
   for (Exam exam : exams) {
      if (code.equals(exam.getCourse().getCode())) {
         lastExam = exam;
      }
   }
   return lastExam;
}
 
public boolean hasPassed(String code) {
   Exam exam = getLastExam(code);
   return exam != null && exam.isPass();
}

public double countCredits() {
   // first collect all course codes
   Collection<String> codes = new ArrayList<String>();
   for (Exam exam : exams) {
      String code = exam.getCourse().getCode();
      if (! codes.contains(code)) {
         codes.add(code);
      }
   }
   // check last exam result for each course code and add credit if passed
   double sum = 0;
   for (String code : codes) {
      Exam exam = getLastExam(code);
      if (exam.isPass()) {
         sum += exam.getCourse().getCredits();
      }
   }
   return sum;
}

public Collection<Exam> readExams(Reader input) {
   Collection<Exam> exams = new ArrayList<>();
   Scanner scanner = new Scanner(input);
   String lastSemester = null;
   while (scanner.hasNextLine()) {
      String line = scanner.nextLine();
      String[] tokens = line.split(" ");
      if (tokens.length == 1) {
         try {
            Course.checkTime(tokens[0]);
            lastSemester = tokens[0];
            continue;
         } catch (IllegalArgumentException e) {
         }
      }
      try {
         Course course = new Course(tokens[0]);
         course.setTime(lastSemester);
         course.setCredits(Double.valueOf(tokens[1]));
         for (int i = 2; i < tokens.length; i++) {
            exams.add(new Exam(course, tokens[i].charAt(0)));
         }
      } catch (RuntimeException e) {
      }
   }
   scanner.close();
   return exams;
}

public ExamRequirement(String course, int sinceYear) {
   this(course, sinceYear, 'E');
}

private boolean acceptsCourse(Course course) {
   return this.course.equals(course.getCode()) && course.getYear() >= sinceYear;
}

public final static ExamRequirement atLeastCInJava = new ExamRequirement("TDT4100", 0, 'C');

private boolean acceptsCourse(Course course) {
   return acceptsCourseCode(course.getCode()) && course.getYear() >= sinceYear;
}

protected boolean acceptsCourseCode(String course) {
   return course.equals(this.course);
}

@Override
protected boolean acceptsCourseCode(String course) {
   return course.startsWith(this.course);
}

public interface IExamRequirement {
   public boolean accepts(Exam exam);
}

public static IExamRequirement atLeastCInJave = (exam) -> "TDT4100".equals(exam.getCourse().getCode()) && exam.getGrade() <= 'C';