Universidad Carlos III de Madrid

Solutions

The solutions of this exercise are included in the following listings:

// Point class
// (c) 2008 IT

public class Point {
  private double x;
  private double y;

  // Constructor
  public Point(double x, double y) {
    this.x = x;
    this.y = y;
  }

  /**
   * Returns the coordinates of the point in a string
   */
  public String toString() {
    // '+' operator in String objects does not mean mathematical sum, but
    // concatenation of strings
    return "(" + x + ", " + y + ")";
  }

  /**
   * Returns the distance to the origin
   */
  public double distanceToOrigin() {
    // It can be also calculated calling to
    // distance(new Point(0,0))
    return Math.sqrt(x * x + y * y);
  }

  /* Getter methods */
  public double getX() {
    return x;
  }

  public double getY() {
    return y;
  }

  /** Returns the distance to another point */
  public double distance(Point anotherPoint) {
    double x1;
    double y1;

    x1 = x - anotherPoint.getX();
    y1 = y - anotherPoint.getY();
    return Math.sqrt(x1 * x1 + y1 * y1);
  }

  /** Returns the quadrant */
  public int quadrant() {
    if (x > 0.0 && y > 0.0) {
      return 1;
    } else if (x < 0.0 && y > 0.0) {
      return 2;
    } else if (x < 0.0 && y < 0.0) {
      return 3;
    } else if (x > 0.0 && y < 0.0) {
      return 4;
    } else {
      // (x==0.0 || y==0.0)
      return 0;
    }
  }

  /**
   * Returns the nearest point of the array in the parameter or null if array is
   * empty
   * 
   * @param otherPoints
   * @return
   */
  public Point nearest(Point[] otherPoints) {
    Point nearestPoint = null;
    double minDistance;
    double distance;

    if (otherPoints != null && otherPoints.length > 0) {
      // Start storing the first point in the array as the nearest one
      minDistance = distance(otherPoints[0]);
      nearestPoint = otherPoints[0];

      for (int i = 1; i < otherPoints.length; i++) {
        // If nearer point is found, this is the new nearest one
        distance = distance(otherPoints[i]);
        if (distance < minDistance) {
          distance = minDistance;
          nearestPoint = otherPoints[i];
        }
      }
    }

    return nearestPoint;
  }
}

	  

// TestingPoint
// (c) 2007 IT
public class TestingPoint {

  public static void main(String args[]) {

    // Check the number of arguments (the two coordinates)
    if (args.length != 2) {
      System.out.println("Usage:");
      System.out.println("  java TestingPoint x y");
      System.out.println("where x and y are the coordinates of a point.");
      return;
    }

    // Handle exceptions
    try {
      double x = Double.parseDouble(args[0]);
      double y = Double.parseDouble(args[1]);

      Point p = new Point(x, y);
      System.out.println("The point is " + p.toString());
      System.out.println("Its distance to origin is " + p.distanceToOrigin());
      System.out.println("Its X coordinate is " + p.getX()
          + " and its Y coordinate is " + p.getY());

      System.out.println("It is located in the quadrant" + p.quadrant());

      Point[] pointsArray = new Point[5];
      pointsArray[0] = new Point(1, 1);
      pointsArray[1] = new Point(5, 3);
      pointsArray[2] = new Point(10, 10);
      pointsArray[3] = new Point(-3, 2);
      pointsArray[4] = new Point(-4, -5);

      for (int i = 0; i < pointsArray.length; i++) {
        System.out.println("Its distance to the point "
            + pointsArray[i].toString() + " is " + p.distance(pointsArray[i]));
      }
      System.out.println("The nearest point is " + p.nearest(pointsArray));
    } catch (Exception e) {
      System.out.println("Error in the arguments of the command line.");
      return;
    }

  }
}
	  

// Testing triangle
// (c) 2007 IT
public class TestingTriangle {

  public static void main(String args[]) {

    // Checking number of arguments(Two coordinates for every point)
    if (args.length != 6) {
      System.out.println("Usage:");
      System.out.println("  java PruebaTriangulo x1 y1 x2 y2 x3 y3");
      System.out.println("where (xi,yi) are the coordinates of every vertex");
      return;
    }

    // Handle exceptions
    try {
      double x1 = Double.parseDouble(args[0]);
      double y1 = Double.parseDouble(args[1]);
      double x2 = Double.parseDouble(args[2]);
      double y2 = Double.parseDouble(args[3]);
      double x3 = Double.parseDouble(args[4]);
      double y3 = Double.parseDouble(args[5]);

      // Vertexes and the triangle are finally created
      Point v1 = new Point(x1, y1);
      Point v2 = new Point(x2, y2);
      Point v3 = new Point(x3, y3);
      Triangle t = new Triangle(v1, v2, v3);

      // Displaying the info
      System.out.println("The triangle has vertexes " + v1.toString() + ", "
          + v2.toString() + ", " + v3.toString());

      double[] edgesLength = t.edgesLength();
      System.out.println("Its edges are " + edgesLength[0] + ", "
          + edgesLength[1] + ", " + edgesLength[2] + " long");
    } catch (Exception e) {
      System.out.println("Error in the arguments of the command line");
      return;
    }

  }
}
	  

/**
 * Triangle.java
 * 
 * (c) DIT-UC3M 2008
 * 
 */

public class Triangle {

  /** Vertexes of the triangle */
  private Point vertex1;
  private Point vertex2;
  private Point vertex3;

  /** Constructor of a triangle with their vertexes */
  public Triangle(Point vertex1, Point vertex2, Point vertex3) {

    this.vertex1 = vertex1;
    this.vertex2 = vertex2;
    this.vertex3 = vertex3;

  }

  /** Returns an array with the length of every edge of the triangle */
  public double[] edgesLength() {
    double edgesLength[] = new double[3];

    // Length 1->2
    edgesLength[0] = vertex1.distance(vertex2);
    // Length 2->3
    edgesLength[1] = vertex2.distance(vertex3);
    // Length 3->1
    edgesLength[2] = vertex3.distance(vertex1);

    return edgesLength;
  }
}

	  

Solution

The solution of these exercises are included in the following listings:

import java.io.*;

public class Date {

  /**
   * Months of the year in order, to facilitate the conversion to integer format
   * 
   * The number of the month is the same as the position of the name of the
   * month in this array plus 1. (because the positions in the array start in 0,
   * but months start in 1)
   */
  private static final String[] months = { "January", "February", "March",
      "April", "May", "June", "July", "August", "September", "October",
      "November", "December" };

  // ATTRIBUTES

  private int day;
  private int month;
  private int year;

  // CONSTRUCTORS

  public Date(int day, int month, int year) throws ExceptionDate {

    checkDate(day, month, year);

    this.day = day;
    this.month = month;
    this.year = year;

  }

  public Date(String sDay, String sMonthName, String sYear)
      throws ExceptionDate {

    // Convert strings to number
    try {
      day = Integer.parseInt(sDay);
      year = Integer.parseInt(sYear);

    } catch (NumberFormatException nfe) {
      // Error converting a string to a number
      throw new ExceptionDate("Wrong date");
    }

    month = getMonth(sMonthName);

    // Checking that values have sense
    checkDate(day, month, year);

  }

  // ACCESORS

  public int getDay() {
    return day;
  }

  public int getMonth() {
    return month;
  }

  public int getYear() {
    return year;
  }

  public void setDay(int day) throws ExceptionDate {
    checkDate(day, this.month, this.year);
    this.day = day;
  }

  public void setMonth(int month) throws ExceptionDate {
    checkDate(this.day, month, this.year);
    this.month = month;
  }

  public void setYear(int year) throws ExceptionDate {
    checkDate(day, month, year);
    this.year = year;
  }

  // METHODS

  public String toString() {
    return (day + " of " + months[month - 1] + ", " + year);
  }

  public int compareTo(Date date) {

    int result = 0;

    if (year < date.getYear()) {
      result = -1;
    } else if (year > date.getYear()) {
      result = 1;
    } else { // Years are the same => compare the months

      if (month < date.getMonth()) {
        result = -1;
      } else if (month > date.getMonth()) {
        result = 1;
      } else { // Months are the same => compare the days

        if (day < date.getDay()) {
          result = -1;
        } else if (day > date.getDay()) {
          result = 1;
        } else { // Days are also the same => same date
          result = 0;
        }
      }
    }

    return result;
  }

  // AUXILIAR METHODS

  /**
   * Returns the number of the days of a given month
   */
  private int getDaysFromMonth(int month) throws ExceptionDate {

    int monthDays = 0;

    switch (month) {

    case 1:
    case 3:
    case 5:
    case 7:
    case 8:
    case 10:
    case 12: // months of 31 days
      monthDays = 31;
      break;

    case 4:
    case 6:
    case 9:
    case 11: // months of 30 days
      monthDays = 30;
      break;

    case 2: // February
      if (isLeapYear(year))
        monthDays = 29;
      else
        monthDays = 28;
      break;

    default: // Wrong month
      throw new ExceptionDate("Wrong month");
    }

    return monthDays;

  }

  /**
   * Returns the number of days of a given month
   */
  private int getDaysFromMonth(String month) throws ExceptionDate {
    return getDaysFromMonth(getMonth(month));
  }

  /**
   * Auxiliary method to get the number of a month, given its name. It returns
   * -1 if the text does not refers to any month.
   */
  private static int getMonth(String sMonthName) throws ExceptionDate {

    // Get the number of the month
    int month = -1;
    for (int i = 0; i < months.length && month == 0; i++) {
      if (months[i].equalsIgnoreCase(sMonthName)) {
        // The month referes to this element in the array
        month = i + 1;
      }
    }

    return month;
  }

  /**
   * Auxiliary method to check if a date is valid or not
   */
  private void checkDate(int day, int month, int year) throws ExceptionDate {

    // Check that the day is valid
    // (The getMonthDay already checks if the month is valid)
    if ((day <= 0) || (day > getDaysFromMonth(month))) {
      throw new ExceptionDate("Wrong date");
    }

  }

  /**
   * Checks if a year is a leap year A year is leap year if it is multiple of 4
   * and not multiple of 100, and the multiple of 400.
   */
  private boolean isLeapYear(int year) {
    return ((((year % 4) == 0) && ((year % 100) != 0)) || ((year % 400) == 0));
  }

  public static Date readDate() {

    BufferedReader entry = new BufferedReader(new InputStreamReader(System.in));
    Date date = null;
    String sDay, sMonth, sYear; // Variables to store the entry of the user
    int iMonth;

    boolean correct = false;

    do {

      try {

        System.out.print("Enter day: ");
        System.out.flush();
        sDay = entry.readLine();
        System.out.print("Enter month: ");
        System.out.flush();
        sMonth = entry.readLine();
        System.out.print("Enter year: ");
        System.out.flush();
        sYear = entry.readLine();

        // Check if the user has entered the name of the month
        iMonth = getMonth(sMonth);

        if (iMonth == -1) {
          // Check if the user has entered the number of the month
          iMonth = Integer.parseInt(sMonth);
        }

        date = new Date(sDay, months[iMonth], sYear);
        correct = true;

      } catch (Exception ex) {
        correct = false;
      }

    } while (!correct);

    return date;
  }

  public Date moreRecentDate(Date[] dates) {

    Date date = null;

    if ((dates != null) && (dates.length > 0)) {

      int max = 0;
      for (int i = 1; i < dates.length; i++) {
        if (dates[max].compareTo(dates[i]) < 0) {
          max = i;
        }
      }
      date = dates[max];
    }

    return date;

  }

}

	   

/**
 * Exception ExceptionDate is thrown when a Date object is created with wrong
 * data.
 */
public class ExceptionDate extends Exception {

  /**
   * Default constructor, creates an exception without a descriptive message.
   */
  public ExceptionDate() {
    super(); // invoke the constructor of the base class Exception
  }

  /**
   * Constructor with parameters, it creates an exception with a descriptive
   * message of the error.
   * 
   * @param message
   *          descriptive message of the error that creates the exception.
   */
  public ExceptionDate(String message) {
    super(message); // invoke the constructor of the base class Exception
  }
}