gistfile1.java

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class Gy2_1 {
    static class Point {
        private Integer x, y;

        Point(Integer x, Integer y) {
            this.x = x;
            this.y = y;
        }

        Integer getX() {
            return x;
        }

        Integer getY() {
            return y;
        }

        @Override
        public String toString() {
            return "(" + getX() + ", " + getY() + ")";
        }

        /**
         * Compare points by distance from a third point.
         */
        private static class DistanceFromComparator implements Comparator<Point> {
            private Point distanceFrom;

            public DistanceFromComparator(Point distanceFrom) {
                this.distanceFrom = distanceFrom;
            }

            private Double distance(Point p) {
                return Math.sqrt(
                        Math.pow(distanceFrom.getX() - p.getX(), 2) +
                        Math.pow(distanceFrom.getY() - p.getY(), 2)
                );
            }

            @Override
            public int compare(Point a, Point b) {
                return (int) Math.signum(distance(a) - distance(b));
            }
        }

        /**
         * @return A DistanceFromComparator using this point as the reference
         */
        public Comparator<Point> distanceFromComparator() {
            return new DistanceFromComparator(this);
        }
    }

    public static void main(String[] args) {
        checkMinimumArgs(2, args);
        checkEvenArgs(args);
        one(args);
    }

    private static void one(String[] args) {
        List<Point> points = readPoints(args);

        Point furthestPoint = Collections.max(points, new Point(0, 0).distanceFromComparator());
        System.out.println("1. Furthest from origo: " + furthestPoint.toString());

        Point nearestPoint = Collections.min(points.subList(1, points.size()), points.get(0).distanceFromComparator());
        System.out.println("1.b. Nearest first point: " + nearestPoint.toString());
    }

    private static void checkMinimumArgs(Integer minimum, String[] args) {
        if (args.length < minimum) {
            throw new RuntimeException("Must have at least " + minimum + " arguments, got only " + args.length);
        }
    }

    private static void checkEvenArgs(String[] args) {
        if (args.length % 2 != 0) {
            throw new RuntimeException("Must get even number of arguments");
        }
    }

    private static List<Point> readPoints(String[] args) {
        LinkedList<Point> points = new LinkedList<Point>();
        for (Integer i = 0; i < args.length; i += 2) {
            Integer x = readInteger(i, args[i]);
            Integer y = readInteger(i+1, args[i+1]);
            Point p = new Point(x, y);
            points.add(p);
            System.out.println("Read point " + p);
        }
        return points;
    }

    private static Integer readInteger(Integer i, String arg) {
        try {
            return Integer.parseInt(arg, 10);
        } catch (NumberFormatException e) {
            throw new RuntimeException("Failed to parse " + i + "-th argument as number: " + arg);
        }
    }
}