-
Notifications
You must be signed in to change notification settings - Fork 0
/
Point.java
139 lines (124 loc) · 4.26 KB
/
Point.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
/******************************************************************************
* Compilation: javac Point.java
* Execution: java Point
* Dependencies: none
*
* An immutable data type for points in the plane.
* For use on Coursera, Algorithms Part I programming assignment.
*
******************************************************************************/
import java.util.Comparator;
import edu.princeton.cs.algs4.StdDraw;
import edu.princeton.cs.algs4.StdOut;
public class Point implements Comparable<Point> {
private final int x; // x-coordinate of this point
private final int y; // y-coordinate of this point
/**
* Initializes a new point.
*
* @param x the <em>x</em>-coordinate of the point
* @param y the <em>y</em>-coordinate of the point
*/
public Point(int x, int y) {
/* DO NOT MODIFY */
this.x = x;
this.y = y;
}
/**
* Draws this point to standard draw.
*/
public void draw() {
/* DO NOT MODIFY */
StdDraw.point(x, y);
}
/**
* Draws the line segment between this point and the specified point to standard
* draw.
*
* @param that the other point
*/
public void drawTo(Point that) {
/* DO NOT MODIFY */
StdDraw.line(this.x, this.y, that.x, that.y);
}
/**
* Returns the slope between this point and the specified point. Formally, if
* the two points are (x0, y0) and (x1, y1), then the slope is (y1 - y0) / (x1 -
* x0). For completeness, the slope is defined to be +0.0 if the line segment
* connecting the two points is horizontal; Double.POSITIVE_INFINITY if the line
* segment is vertical; and Double.NEGATIVE_INFINITY if (x0, y0) and (x1, y1)
* are equal.
*
* @param that the other point
* @return the slope between this point and the specified point
*/
public double slopeTo(Point that) {
if (this.x == that.x && this.y == that.y)
return Double.NEGATIVE_INFINITY;
if (this.x == that.x) // vertical
return Double.POSITIVE_INFINITY;
if (this.y == that.y) // horizontal
return +0.0;
return (that.y - this.y) / (that.x - this.x);
}
/**
* Compares two points by y-coordinate, breaking ties by x-coordinate. Formally,
* the invoking point (x0, y0) is less than the argument point (x1, y1) if and
* only if either y0 < y1 or if y0 = y1 and x0 < x1.
*
* @param that the other point
* @return the value <tt>0</tt> if this point is equal to the argument point (x0
* = x1 and y0 = y1); a negative integer if this point is less than the
* argument point; and a positive integer if this point is greater than
* the argument point
*/
@Override
public int compareTo(Point that) {
if (this.y == that.y && this.x == that.x)
return 0;
if (this.y < that.y)
return -1;
if (this.y == that.y)
if (this.x < that.x)
return -1;
return 1;
}
/**
* Compares two points by the slope they make with this point. The slope is
* defined as in the slopeTo() method.
*
* @return the Comparator that defines this ordering on points
*/
public Comparator<Point> slopeOrder() {
//TODO: implement slopeOrder()
/* YOUR CODE HERE */
return null;
}
/**
* Returns a string representation of this point. This method is provide for
* debugging; your program should not rely on the format of the string
* representation.
*
* @return a string representation of this point
*/
public String toString() {
/* DO NOT MODIFY */
return "(" + x + ", " + y + ")";
}
/**
* Unit tests the Point data type.
*/
public static void main(String[] args) {
Point p1=new Point(1,1);
Point p2=new Point(1,2);
Point p3=new Point(2,2);
Point p4 = new Point(1, 3);
Point p5=new Point(2,2);
Point p6=new Point(1,5);
StdOut.println(p1.compareTo(p2));
StdOut.println(p2.compareTo(p3));
StdOut.println(p5.compareTo(p1));
StdOut.println(p3.compareTo(p5));
StdOut.println(p4.compareTo(p6));
}
}