Comparable, Comparator, and Sorting

import java.util.*;

public class NoOrder {

    // No natural order. Leave it that way.
    static class Student {
        final int marks;
        final String name;
        Student(int m, String n) { marks = m; name = n; }
        @Override public String toString() { return name + "(" + marks + ")"; }
    }

    // TODO: a second class, SortableStudent, the same but Comparable by marks

    static List<Student> three() {
        return new ArrayList<>(List.of(
                new Student(95, "Aditya"), new Student(85, "Rohit"), new Student(90, "Cipher")));
    }

    // These three compile. Predict what they do at run time, then find out.
    static String tryTreeSet()       { return "ok"; }  // TODO: new TreeSet<>(three())
    static String tryPriorityQueue() { return "ok"; }  // TODO: new PriorityQueue<>(three())
    static String tryListSort()      { return "ok"; }  // TODO: three().sort(null)

    // These two do NOT compile. Write each line, read the error, comment it out,
    // and record your answer here.
    static boolean collectionsSortCompiles() { return true; }  // TODO
    static boolean collectionsMaxCompiles()  { return true; }  // TODO

    // Add ONE student to an empty TreeSet, catching the failure. How many got in?
    static int treeSetSizeAfterFirstAdd() {
        return 1; // TODO
    }

    // Sort your SortableStudent version. Return the names in order.
    static List<String> sortedOnceComparable() {
        return List.of(); // TODO
    }

    public static void main(String[] args) {
        // TODO: print everything and read the two groups side by side
    }
}

import java.util.*;

public class Overflow {

    static int bySubtraction(int a, int b) { return a - b; }
    static int byCompare(int a, int b)     { return Integer.compare(a, b); }

    // Do the two answers have the same SIGN? That is all a comparator promises.
    static boolean signsAgree(int a, int b) {
        return true; // TODO
    }

    // Sort a copy with each comparator.
    static List<Integer> sortWithSubtraction(List<Integer> values) {
        return List.of(); // TODO
    }

    static List<Integer> sortWithCompare(List<Integer> values) {
        return List.of(); // TODO
    }

    public static void main(String[] args) {
        int[][] pairs = {
                {5, 3}, {3, 5}, {7, 7},
                {2_000_000_000, -2_000_000_000},
                {-2_000_000_000, 2_000_000_000},
        };
        // TODO: print both methods for each pair, and mark where the signs disagree
        // TODO: sort a list holding those extreme values with each one
    }
}

import java.util.*;

public class Compose {

    record Unit(String name, int readiness, String base) { }

    static List<Unit> roster() {
        return new ArrayList<>(List.of(
                new Unit("Atlas",  88, "North"),
                new Unit("Beacon", 42, "South"),
                new Unit("Cipher", 88, "North"),
                new Unit("Drift",  61, "South")));
    }

    // All five return just the names, in order, and must not change the list given.
    // Do all five WITHOUT writing a compare method body.

    static List<String> byName(List<Unit> units) {
        return List.of(); // TODO
    }

    static List<String> byReadinessLowestFirst(List<Unit> units) {
        return List.of(); // TODO: comparingInt, not comparing
    }

    static List<String> byReadinessHighestFirst(List<Unit> units) {
        return List.of(); // TODO
    }

    static List<String> byBaseThenReadinessThenName(List<Unit> units) {
        return List.of(); // TODO: three levels
    }

    static List<String> byNameIgnoringCase(List<Unit> units) {
        return List.of(); // TODO
    }

    public static void main(String[] args) {
        // TODO: print all five
        // TODO: write one of them as an explicit anonymous class and compare the code
    }
}

import java.util.*;
import java.math.BigDecimal;

public class Disagree {

    // compareTo looks at marks only. equals looks at marks AND name. They disagree.
    static class Student implements Comparable<Student> {
        final int marks;
        final String name;
        Student(int m, String n) { marks = m; name = n; }
        @Override public int compareTo(Student o) { return Integer.compare(marks, o.marks); }
        @Override public boolean equals(Object o) {
            return o instanceof Student s && s.marks == marks && s.name.equals(name);
        }
        @Override public int hashCode() { return Objects.hash(marks, name); }
        @Override public String toString() { return name + "(" + marks + ")"; }
    }

    // TODO: a second class FixedStudent, where compareTo and equals agree

    static List<Student> twoOnNinety() {
        return List.of(new Student(90, "Aditya"), new Student(90, "Rohit"));
    }

    static int hashSetSize() { return 0; }  // TODO
    static int treeSetSize() { return 0; }  // TODO

    static int fixedHashSetSize() { return 0; }  // TODO
    static int fixedTreeSetSize() { return 0; }  // TODO

    // The same split, in the standard library.
    static boolean bigDecimalEquals() { return true; }  // TODO: 1.0 equals 1.00 ?
    static int bigDecimalCompare()    { return -1; }    // TODO: 1.0 compareTo 1.00 ?

    public static void main(String[] args) {
        // TODO: print all six and read them together
    }
}

import java.util.*;

public class RegistryReports {

    static class Unit implements Comparable<Unit> {
        final String name;
        final int id;
        final double readiness;
        final String base;

        Unit(String n, int i, double r, String b) { name = n; id = i; readiness = r; base = b; }

        // What is the NATURAL order of a Unit? Decide, then defend it in a comment.
        // Which field is unique, never changes, and means the same to every reader?
        @Override public int compareTo(Unit o) { return 0; }  // TODO

        @Override public String toString() { return name + "#" + id; }
    }

    // Deliberately not in natural order, so you can see the sort do something.
    static List<Unit> roster() {
        return new ArrayList<>(List.of(
                new Unit("Drift",  104, 61.0, "South"),
                new Unit("Atlas",  101, 88.0, "North"),
                new Unit("Cipher", 103, 88.0, "North"),
                new Unit("Beacon", 102, 42.0, "South")));
    }

    static List<String> defaultOrder(List<Unit> roster)          { return List.of(); }  // TODO
    static List<String> byReadiness(List<Unit> roster)           { return List.of(); }  // TODO: highest first
    static List<String> byBaseThenReadiness(List<Unit> roster)   { return List.of(); }  // TODO
    static List<String> topThree(List<Unit> roster)              { return List.of(); }  // TODO
    static List<String> throughTreeSet(List<Unit> roster)        { return List.of(); }  // TODO

    // Sort by the WEAKER key first, then the stronger one. A stable sort keeps both.
    static List<String> sortedTwiceForCompoundOrder(List<Unit> roster) {
        return List.of(); // TODO
    }

    public static void main(String[] args) {
        // TODO: print all six reports from the same roster
    }
}