前言
经过了这几次大作业的洗礼，我已经对Java的三大基本特性有了一个初步的认识。接下来，我会对每次的作业作一个简单的分析，以下将从知识点、题量、难度等方面讲述。
1.知识点
2.题量
3.难度
设计分析
类代码
这里先放四边形和五边形大作业的类代码块，代码都有注释，有需要的可以看看。下面就不放代码了，只做分析。(类包括四边形、五边形、多边形以及点线的类代码。)
1）点类:
点击查看代码
import java.util.ArrayList;
/**
* 点类
*/
public class Point {
//x、y 坐标
private double x;
private double y;
public Point() {
}
public Point(double x, double y) {
this.x = x;
this.y = y;
}
// get 、set 方法
public void setX(double x) {
this.x = x;
}
public void setY(double y) {
this.y = y;
}
public double getX() {
return x;
}
public double getY() {
return y;
}
/**
* 计算两点之间的距离
*
* @param p 计算距离的点
* @return 返回距离值double
*/
public double getDistanceTo(Point p) {
return Math.sqrt(Math.pow(p.getX() - this.x, 2) + Math.pow(p.getY() - this.y, 2));
}
/**
* 比较两点是否相等
*
* @param p 比较的点
* @return 返回是否相等的 bool 值
*/
public boolean equals(Point p) {
if (p.getX() == x && p.getY() == y) {
return true;
}
return false;
}
@Override
public String toString() {
return "Point [x=" + x + ", y=" + y + "]";
}
/**
* 处理传入的点集 除去重合的点，以及 除去三点共线的中间点
* 还有bug 不能通过所有测试点
*/
public static Point[] disposePointSet(Point[] vertexes) {
int[] flag = new int[vertexes.length]; // 标记
for (int i = 0; i < flag.length; i++)
flag[i] = 0;
int num =vertexes.length;
// 检查每一个点是否重合 选择是否进行判断
for (int i = 0; i < vertexes.length; ++i) {
for (int j = i + 1; j < vertexes.length; ++j) {
if (vertexes[i].equals(vertexes[j])) {
flag[j] = 1;
num--;
}
}
}
// 任意三点共线 则去掉一个中间点 需要在去除重复点的基础上
for (int i = 0; i < vertexes.length; ++i) {
if (Line.isThreePointsCollinear(vertexes[(i-1+vertexes.length)%vertexes.length],vertexes[i],vertexes[(i+1+vertexes.length)%vertexes.length])) {
flag[i] = 1;
num--;
}
}
//处理
Point[] p = new Point[num];
for (int i = 0,j = 0; j < flag.length;j++)
if (flag[j] != 1) {
p[i++] = new Point(vertexes[j].getX(),vertexes[j].getY());
}
// for(int i=0;i< p.length;i++) {
// System.out.println(p[i].toString());
// }
return p;
}
}
2）线类：
点击查看代码
//直线 Ax + By + C=0
public class Line {
// 构成直线的两个点
private Point p1;
private Point p2;
// 直线的三个参数
private double A;
private double B;
private double C;
public Line() {
}
public Line(Point s1, Point s2) {
this.A = s2.getY() - s1.getY();
this.B = s1.getX() - s2.getX();
this.C = s1.getY() * s2.getX() - s1.getX() * s2.getY();
this.p1 = s1;
this.p2 = s2;
}
// get、set 方法
public Point getP1() {
return p1;
}
public void setP1(Point x) {
this.p1 = x;
}
public Point getP2() {
return p2;
}
public void setP2(Point y) {
this.p2 = y;
}
public double getA() {
return A;
}
public void setA(double a) {
A = a;
}
public double getB() {
return B;
}
public void setB(double b) {
B = b;
}
public double getC() {
return C;
}
public void setC(double c) {
C = c;
}
/**
* 判断两点是否能构成一条直线,即两点不能重合
*
* @return 返回能否构成直线的bool值
*/
public boolean isLegal() {
if (p1.getX() == p2.getX() && p1.getY() == p2.getY()) {
return true;
}
return false;
}
/**
* 判断 该直线是否有斜率
*
* @return 返回直线是否有斜率的bool值
*/
public boolean haveSlope() {
if (p1.getX() != p2.getX())
return true;
else
return false;
}
/**
* 计算直线的斜率 (y1-y2)/(x1-x2)
*
* @return 返回直线的斜率
*/
public double getSlope() {
return (p2.getY() - p1.getY()) / (p2.getX() - p1.getX());
}
/**
* 计算点到直线的距离
*
* @param p 传入该点
* @return 返回点到直线的距离
*/
public double getDistanceToLine(Point p) {
double ji = Math.sqrt(A * A + B * B);
return Math.abs(A * p.getX() + B * p.getY() + C) / ji;
}
/**
* 判断点是否在线上
*
* @param p 需要判断的点
* @return 返回点是否在直线上的bool值
*/
public boolean isPointOnLine(Point p) {
if (((p1.getX() - p.getX()) * (p2.getY() - p.getY()) - (p1.getY() - p.getY()) * (p2.getX() - p.getX())) == 0) {
return true;
}
return false;
}
/**
* 判断 两线是否为同一条线 y = kx + b 判断k和y是否相等
*
* @param l 需要判断的线
* @return 返回两条线是否为同一条线的bool值
*/
public boolean isSameLine(Line l) {
if (this.getSlope() == l.getSlope() && this.isPointOnLine(l.getP1()) && this.isPointOnLine(l.getP2())) {
return true;
}
return false;
}
/**
* 判断两直线是否平行
*
* @param l 需要判断的直线
* @return 返回两直线是否平行的bool值
*/
public boolean isParallelWithLine(Line l) {
if (l.getSlope() == getSlope())
return true;
else
return false;
}
/**
* 计算两直线的交点
*
* @param l 需要判断的直线
* @return 返回交点的坐标
*/
public Point getIntersectPoint(Line l) {
double d = l.getA() * this.getB() - l.getB() * this.getA();
return new Point((l.getB() * this.getC() - l.getC() * this.getB()) / d,
(l.getC() * this.getA() - l.getA() * this.getC()) / d);
}
/**
* 判断两直线是否垂直
*
* @param l 需要判断的线
* @return 返回直线是否垂直的bool值
*/
public boolean isVerticalLine(Line l) {
if (p1.getDistanceTo(l.p1) == l.getDistanceToLine(this.p1)) {
return true;
}
return false;
}
/**
* 判断点是否在线的左侧
*
* @param l 传入线
* @param p 需要判断位置的点
* @return 返回点是否在线的左侧的bool值
*/
public boolean isPointOnLineLeft(Point p) {
if (((p1.getX() - p.getX()) * (p2.getY() - p.getY()) - (p1.getY() - p.getY()) * (p2.getX() - p.getX())) > 0) {
return true;
}
return false;
}
/**
* 判断点是否在线的右侧
*
* @param l 传入线
* @param p 需要判断的点
* @return 返回点是否在线的右侧的bool值
*/
public boolean isPointOnLineRight(Point p) {
if ((p1.getX() - p.getX()) * (p2.getY() - p.getY()) - (p1.getY() - p.getY()) * (p2.getX() - p.getX()) < 0) {
return true;
}
return false;
}
/**
* 判断点是否在构成线的两点之间 不包括点重合
*
* @param p 需要判断的点
* @return 返回点是否在线段两点之间的bool值
*/
public boolean isBetweenLineOfPoint(Point p) {
if ((p.getDistanceTo(p1) + p.getDistanceTo(p2)) == p1.getDistanceTo(p2) && !p.equals(p1) && !p.equals(p2))
return true;
else
return false;
}
/**
* 三点共线 且任意两点不重合
* @param 传入三个点
* @return 返回三点是否共线的Boolean 值
*/
public static boolean isThreePointsCollinear(Point p,Point p1,Point p2) {
if(!p.equals(p1)&&!p.equals(p2)&&!p2.equals(p1)&&((p1.getX() - p.getX()) * (p2.getY() - p.getY()) - (p1.getY() - p.getY()) * (p2.getX() - p.getX())) == 0) {
return true;
}
return false;
}
}
3）多边形类：
点击查看代码
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Objects;
public class Polygon {
protected Line[] sides;
protected Point[] vertexes;
/**
* 多边形构造方法 这里默认为 p.length = size 即有相同多的点去构成对应的多边形 默认按点顺序连接
*
* @param p 构成多边形的点集Point[]
* @param size 需要构成多边形的边数int
*/
public Polygon(Point[] p, int size) {
//
if (p.length != size)
throw new RuntimeException("polygon constructor error");
// 检查每一个点是否重合 选择是否进行判断
for (int i = 0; i < p.length; ++i) {
for (int j = i + 1; j < p.length; ++j) {
if (p[i].equals(p[j])) {
}
}
}
vertexes = p;
sides = new Line[size];
// 构造边
for (int i = 0; i < p.length; ++i) {
sides[i] = new Line(vertexes[i], vertexes[(i + 1) % p.length]);
}
}
/**
* 判断点集是否能构成对应的n边形
*
* @param size 对应构成多边形的边数
* @return 返回是否能构成对应的多边形
*/
public boolean isThePolygon(int size) {
int num = vertexes.length;
// 检查每一个点是否重合 选择是否进行判断
for (int i = 0; i < vertexes.length; ++i) {
for (int j = i + 1; j < vertexes.length; ++j) {
if (vertexes[i].equals(vertexes[j])) {
num--;
}
}
}
// 任意三点共线 则去掉一个中间点
for (int i = 0; i < sides.length; ++i) {
if (sides[i].isPointOnLine(vertexes[(i + 2) % vertexes.length])) {
num--;
}
}
// 非相邻边无交点判断 即按顺序相连接
for (int i = 0; i < sides.length; i++) {
for (int j = i + 2; j < i + 2 + sides.length - 3; j++) {
// 不平行且交点未在边上
if (!sides[i].isParallelWithLine(sides[j % sides.length])
&& sides[i].isBetweenLineOfPoint(sides[i].getIntersectPoint(sides[j % sides.length]))) {
return false;
}
}
}
if (num == size)
return true;
else
return false;
}
/**
* 暴力计算分割的面积
*/
public void splitPolygon() {
}
/**
* 判断多边形的凹凸 需判断sides.length>3 即四边及以上才具有凹凸性 利用向量的叉乘 若两边叉乘值小于0 则夹角大于180
*
* @return 凸返回true 凹返回false
*/
public boolean isConcaveOrConvex() {
double multip = 0;
double a, b, c, d;
for (int i = 0; i < vertexes.length; i++) {
// 向量1
a = vertexes[i].getX() - vertexes[(i + vertexes.length - 1) % vertexes.length].getX();
b = vertexes[i].getY() - vertexes[(i + vertexes.length - 1) % vertexes.length].getY();
// 向量2
c = vertexes[(i + 1) % vertexes.length].getX() - vertexes[i].getX();
d = vertexes[(i + 1) % vertexes.length].getY() - vertexes[i].getY();
// 叉乘 交叉相乘
multip = (a * d) - (c * b);
if (multip < 0)
return false;
}
return true;
}
/**
* 计算对应多边形的周长 循环计算每边长度相加
*
* @return 返回该多边形的周长
*/
public double getPerimeter() {
double sum = 0;
for (int i = 0; i < vertexes.length; i++) {
sum += vertexes[i].getDistanceTo(vertexes[(i + 1) % vertexes.length]);
}
return sum;
}
/**
* 计算对应多边形的面积 利用叉乘的定义
*
* @return 返回该多边形的面积
*/
public double getArea() {
double area = 0;
double a, b, c, d;
// 从第二点开始遍历节点
for (int i = 1; i < vertexes.length - 1; i++) {
// 向量a
a = vertexes[i].getX() - vertexes[0].getX();
b = vertexes[i].getY() - vertexes[0].getY();
// 向量b
c = vertexes[i + 1].getX() - vertexes[0].getX();
d = vertexes[i + 1].getY() - vertexes[0].getY();
// 叉乘
area += a * d - b * c;
}
return area / 2;
}
// public int getIntersectionNumPolygon(Line l) {
//
// }
/**
* 判断点是否与多边形的顶点重合
*
* @param p 需要判断的点
* @return 返回该点是否与多边形顶点重合的bool值
*/
public boolean isPolygonVertex(Point p) {
for (Point vertex : vertexes) {
if (p.equals(vertex))
return true;
}
return false;
}
/**
* 判断点是否在多边形的边上 包括顶点重合的情况
*
* @param p 需要判断的点
* @return 返回该点是否在边上的bool值
*/
public boolean isPointOnPolygonSide(Point p) {
// 分别与每边比较
for (int i = 0; i < sides.length; ++i) {
if ((p.getDistanceTo(vertexes[i]) + p.getDistanceTo(vertexes[(i + 1) % vertexes.length])) == sides[i].getP1()
.getDistanceTo(sides[i].getP2()))
return true;
}
return false;
}
/**
* 判断点是否在多边形上 分别判断顶点和边的情况
*
* @param p 需要判断的点
* @return 返回是否在多边形边上的bool值
*/
public boolean isPointOnPolygon(Point p) {
if (isPolygonVertex(p) || isPointOnPolygonSide(p)) {
return true;
} else
return false;
}
/**
* 判断线是否是多边形的边 即与边重合
*
* @param l
* @return
*/
public boolean haveCoincideLine(Line l) {
for (Line line : sides) {
if (l.isSameLine(line)) {
return true;
}
}
return false;
}
/**
* 判断 点是否在多边形里 射线法判断 以传入点 p(x0,y0)、p1(x0 + 1, y0) 构造一线 l 计算 l 与多边形各边交点,
* 并统计交点 x坐标大于 x0 的数量 c 若c为奇数则点一定在多边形内 c为偶数则在多边形外
*
* @param p 需要判断的点
* @return 是否在多边形里的bool值
*/
public boolean isPointInPolygon(Point p) {
Traingle tra[] =new Traingle[vertexes.length];
double sum=0;
for(int i=0;i<vertexes.length;i++) {
tra[i] = new Traingle(new Point[] {p,vertexes[i],vertexes[(i+1+vertexes.length)%vertexes.length]});
}
for(int i=0;i<tra.length;i++)
sum += tra[i].getArea();
return sum == this.getArea();
// int cnt = 0;
// Point p1 = new Point(p.getX() + 1, p.getY());
// Line l = new Line(p1, p);
// for (Line line : sides) {
// Point cross = line.getIntersectPoint(l);
// if (line.isBetweenLineOfPoint(cross))
// if (cross.getX() > p.getX()) {
// ++cnt;
// }
// }
// return cnt % 2 != 0;
}
}
4）四边形类：
点击查看代码
public class Quadrangle extends Polygon {
// 构造函数
public Quadrangle(Point[] p) {
super(p, 4);
}
// 平行四边形
public boolean isParallelQuard() {
if (this.vertexes[0].getDistanceTo(vertexes[1]) == this.vertexes[2].getDistanceTo(vertexes[3])
&& this.vertexes[1].getDistanceTo(vertexes[2]) == this.vertexes[3].getDistanceTo(vertexes[0])) {
return true;
} else
return false;
}
// 矩形
public boolean isRectangle() {
if (this.isParallelQuard()) {
if (this.sides[0].isVerticalLine(this.sides[1])) {
return true;
}
}
return false;
}
// 菱形
public boolean isRhombus() {
if (this.isParallelQuard()) {
if (this.vertexes[0].getDistanceTo(vertexes[1]) == this.vertexes[2].getDistanceTo(vertexes[1])) {
return true;
}
}
return false;
}
// 正方形
public boolean isSquare() {
if (this.isRectangle()) {
if (this.vertexes[0].getDistanceTo(vertexes[1]) == this.vertexes[1].getDistanceTo(vertexes[2])) {
return true;
}
}
return false;
}
// 返回四边形交点数量
public int getIntersectionNum(Line l) {
int num = 0, leftn = 0, rightn = 0;
for (int i = 0; i < this.vertexes.length; i++) {
if (l.isPointOnLineLeft(vertexes[i])) {
leftn++;
}
if (l.isPointOnLineRight(vertexes[i])) {
rightn++;
}
}
// 四边形判断 凹凸
if (this.isConcaveOrConvex()) {
if (leftn == 0 || leftn == 4)
num = 0;
else if ((leftn == 3 && rightn == 0) || (leftn == 0 && rightn == 3))
num = 1;
else
num = 2;
} else {
if (leftn == 0 || leftn == 4)
num = 0;
else if ((leftn == 3 && rightn == 0) || (leftn == 0 && rightn == 3))
num = 1;
else if ((leftn == 1 && rightn == 2) || (leftn == 2 && rightn == 1))
num = 3;
else if (leftn == 2 && rightn == 2)
num = 4;
else
num = 2;
}
return num;
}
// 分割面积 四边形分割
public Polygon splitQuadrangle(Line l) {
Polygon polygon = new Polygon();
Point[] p = new Point[2];
// 分割成两个四边形
for (int i = 0; i < 2; i++) {
if (this.isPointOnPolygon(l.getIntersectPoint(sides[i]))
&& this.isPointOnPolygon(l.getIntersectPoint(sides[i + 2]))) {
p[0] = new Point(l.getIntersectPoint(sides[i]).getX(), l.getIntersectPoint(sides[i]).getY());
p[1] = new Point(l.getIntersectPoint(sides[i + 2]).getX(), l.getIntersectPoint(sides[i + 2]).getY());
polygon = new Quadrangle(new Point[] { p[0], vertexes[i + 1], vertexes[i + 2], p[1] });
}
}
// 分割成一个三角和一个四边形
for (int i = 0; i < sides.length; i++) {
if (this.isPointOnPolygon(l.getIntersectPoint(sides[i]))
&& this.isPointOnPolygon(l.getIntersectPoint(sides[(i + 1) % 4]))) {
p[0] = new Point(l.getIntersectPoint(sides[i]).getX(), l.getIntersectPoint(sides[i]).getY());
p[1] = new Point(l.getIntersectPoint(sides[(i + 1) % 4]).getX(),
l.getIntersectPoint(sides[(i + 1) % 4]).getY());
polygon = new Traingle(new Point[] {p[0], p[1], vertexes[(i + 1) % 4]});
break;
}
}
return polygon;
}
}
5)五边形类：
点击查看代码
import java.util.ArrayList;
public class Pentagon extends Polygon {
public Pentagon(Point[] p) {
super(p, 5);
}
/**
* 求直线与五边形的交点数量
*
* @param l 需要判断的直线
* @return 返回五边形交点数量
*/
public int getIntersectionNum(Line l) {
int num = 0,left = 0,right=0;
for (int i = 0; i < vertexes.length; i++) {
if (l.isPointOnLineLeft(vertexes[i])) {
left++;
}if(l.isPointOnLineRight(vertexes[i])) {
right++;
}
}
if(left==5||left==0)
num=0;
else if((left==4 &&right==0)||(left==0 &&right==4))
num=1;
else num=2;
return num;
}
/**
* 求线切割后的面积
* @param l 传入线
*/
public void splitByLine(Line l) {
int place[] =new int[2],j = 0;//存 交点在线上的位置 包括交点与顶点重合
int flag = 0; //动态确定加入点的位置
ArrayList<Point> points = new ArrayList<Point>();
for(int i=0;i<vertexes.length;i++)
points.add(vertexes[i]);
//对交点操作
for(int i=0;i<vertexes.length&&j<2;i++) {
if (vertexes[i].equals(sides[i].getIntersectPoint(l))) {
place[j++] = i;
}
else if(sides[i].isBetweenLineOfPoint(sides[i].getIntersectPoint(l))) {
points.add(i+1+flag, sides[i].getIntersectPoint(l));
flag++;
place[j++] = i + flag;
}
}
//计算面积
Point p[] = new Point[place[1]-place[0]+1];
for(int i=0;i<p.length;i++) {
p[i] = new Point(points.get(i).getX(),points.get(i).getY());
}
Polygon po =new Polygon(p,p.length);
String temp = String.format("%.3f",po.getArea());
double area1 = Double.parseDouble(temp);
temp = String.format("%.3f",this.getArea() - po.getArea());
double area2 = Double.parseDouble(temp);
System.out.print(" " + Math.min(area1,area2) + " "
+ Math.max(area1,area2));
}
}
7-2 点线形系列4-凸四边形的计算
题目要求如下
用户输入一组选项和数据，进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的顶点相邻。
选项包括：
1：输入四个点坐标，判断是否是四边形、平行四边形，判断结果输出true/false，结果之间以一个英文空格符分隔。
2：输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
3：输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
4：输入六个点坐标，前两个点构成一条直线，后四个点构成一个四边形或三角形，输出直线与四边形（也可能是三角形）相交的交点数量。如果交点有两个，再按面积从小到大输出四边形(或三角形)被直线分割成两部分的面积（不换行）。若直线与四边形或三角形的一条边线重合，输出"The line is coincide with one of the lines"。若后四个点不符合四边形或三角形的输入，输出"not a quadrilateral or triangle"。
后四个点构成三角形的情况：假设三角形一条边上两个端点分别是x、y，边线中间有一点z，另一顶点s：
1）符合要求的输入：顶点重复或者z与xy都相邻，如x x y s、x z y s、x y x s、s x y y。此时去除冗余点，保留一个x、一个y。
2) 不符合要求的输入：z 不与xy都相邻，如z x y s、x z s y、x s z y
5：输入五个点坐标，输出第一个是否在后四个点所构成的四边形（限定为凸四边形，不考虑凹四边形）或三角形（判定方法见选项4）的内部（若是四边形输出in the quadrilateral/outof the quadrilateral，若是三角形输出in the triangle/outof the triangle）。如果点在多边形的某条边上，输出"on the triangle或者on the quadrilateral"。若后四个点不符合四边形或三角形，输出"not a quadrilateral or triangle"。
输入格式:
基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
注意：输出的数据若小数点后超过3位，只保留小数点后3位，多余部分采用四舍五入规则进到最低位。小数点后若不足3位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333，1.0按格式输出为1.0
选项1、2、3中，若四边形四个点中有重合点，输出"points coincide"。
选项4中，若前两个输入线的点重合，输出"points coincide"。
类图以及圈复杂度图：
点线形系列5-凸五边形的计算
题目要求如下
用户输入一组选项和数据，进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入，连续输入的两个顶点是相邻顶点，第一个和最后一个输入的
顶点相邻。
选项包括：
1：输入五个点坐标，判断是否是五边形，判断结果输出 true/false。
2：输入五个点坐标，判断是凹五边形（false）还是凸五边形(true)，如果是凸五边形，则再输出五边形周
长、面积，结果之间以一个英文空格符分隔。 若五个点坐标无法构成五边形，输出"not a pentagon"
3：输入七个点坐标，前两个点构成一条直线，后五个点构成一个五边形、四边形或三角形，输出直线与五
边形、四边形或三角形相交的交点数量。如果交点有两个，再按面积从小到大输出被直线分割成两部分的
面积（不换行）。若直线与多边形形的一条边线重合，输出"The line is coincide with one of the lines"。若
后五个点不符合五边形输入，若前两点重合，输出"points coincide"。
4：输入十个点坐标，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），判断它们两个之
间是否存在包含关系（一个多边形有一条或多条边与另一个多边形重合，其他部分都包含在另一个多边形
内部，也算包含）。
两者存在六种关系：1、分离（完全无重合点） 2、连接（只有一个点或一条边重合） 3、完全重合 4、
被包含（前一个多边形在后一个多边形的内部）5、交错 6、包含（后一个多边形在前一个多边形的内部）。
各种关系的输出格式如下：
1、no overlapping area between the previous triangle/quadrilateral/ pentagon and the
following triangle/quadrilateral/ pentagon
2、the previous triangle/quadrilateral/ pentagon is connected to the following
triangle/quadrilateral/ pentagon
3 、 the previous triangle/quadrilateral/ pentagon coincides with the following
triangle/quadrilateral/ pentagon
4 、 the previous triangle/quadrilateral/ pentagon is inside the following
triangle/quadrilateral/ pentagon
5、the previous triangle/quadrilateral/ pentagon is interlaced with the following
triangle/quadrilateral/ pentagon
6 、 the previous triangle/quadrilateral/ pentagon contains the following
triangle/quadrilateral/ pentagon
5：输入十个点坐标，前、后五个点分别构成一个凸多边形（三角形、四边形、五边形），输出两个多边形
公共区域的面积。注：只考虑每个多边形被另一个多边形分割成最多两个部分的情况，不考虑一个多边形
将另一个分割成超过两个区域的情况。
6：输入六个点坐标，输出第一个是否在后五个点所构成的多边形（限定为凸多边形，不考虑凹多边形），
的内部（若是五边形输出 in the pentagon/outof the pentagon，若是四边形输出 in the quadrilateral/outof
the quadrilateral，若是三角形输出 in the triangle/outof the triangle）。输入入错存在冗余点要排除，冗余
点的判定方法见选项 5。如果点在多边形的某条边上，输出"on the triangle/on the quadrilateral/on the
pentagon"。
以上 3、4、5、6 选项中，若输入的点无法构成多边形，则输出"not a polygon"。输入的五个点坐标可
能存在冗余，假设多边形一条边上两个端点分别是 x、y，边线中间有一点 z，另一顶点 s：
1）符合要求的输入：顶点重复或者 z 与 xy 都相邻，如：x x y s、x z y s、x y x s、s x y y。此时去除冗余点，
保留一个 x、一个 y。
2) 不符合要求的输入：z 不与 xy 都相邻，如：z x y s、x z s y、x s z y
输入格式:
基本格式：选项+":"+坐标 x+","+坐标 y+" "+坐标 x+","+坐标 y。点的 x、y 坐标之间以英文","
分隔，点与点之间以一个英文空格分隔。
输出格式:
基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
注意：输出的数据若小数点后超过 3 位，只保留小数点后 3 位，多余部分采用四舍五入规则
进到最低位。小数点后若不足 3 位，按原始位数显示，不必补齐。例如：1/3 的结果按格式
输出为 0.333，1.0 按格式输出为 1.0