晚风于我皆客的总结性Blog3
前言：第一次作业的第一题学习到了身体质量指数的计算方法且质量指数在什么范围内有什么情况(即学会如何用if函数)，而且学习到了题目的严格要求代码也得遵守，小细节都不行。第一题的难度不是很大，题量不大。第一次作业的第二题首先学习到了1磅和1英寸的国际单位制与英制之间的计算的换算，其次题目要求用浮点数，浮点数有两种表示方式，一种是float，一种是double，在这道题中，若是zhi，chang两个变量全部用double，结果会出错，而且剩余变量也是，我觉得是因为内存的问题和精度的问题，学习到了什么时候用double，什么时候用float，题量不大，也不难，第三题奇数求和学习到了用数组，题量和难度是最低的，第四题学习到了怎么输出空格形式以及浮点数的应用，题量不多，难度一开始觉得挺难，是因为看不懂题，后来就觉得不难了。第五题是游戏角色选择，我学习到了Switch和case的用法，题量少，题目简单，第六题学到了用字符来描述问题解决问题，并且学到如何计算每一位的数字，题量比较麻烦，难度有点大，对于当时来说，第七题学到在浮点数中比较大小精确度在0.01之内而且学到如何将三角形划分几类三角形，难度偏中，题量较大，第八题学到了用巴比伦法求平方根近似值，不能将浮点数写成double，因为float精确到前几位，而double不是，学会用循环，难度较低，题量较小，第九题学会了如何访问字符串的字符，难度适中，题量不多。
第二次作业的第一题我学会了运用古典变量来对情况进行分析，难度较小，题量较小。第二题学会了用一个正则表达式判断输入是否合法以及循环逻辑的结构梳理，难度较大，题量适中。第三题学习到了如何表示一串字符中以n个一维数组分隔开来完成题目，以及循环结构，难度较大，题量不大。
第三次作业的第一题我学会了如何用正则表达式判断一个字符串是否为double类型，以及如何以，将字符内容分隔开和怎么以空格将点坐标分隔开，难度较大，题量较大。第二题学习到了用Switch和case对情况进行甄选，以及跟第一题一样的收获。第三题学会了如何用正则表达式判断一个字符串是否为double类型，以及如何以，将字符内容分隔开和怎么以空格将点坐标分隔开，用Switch和case对情况进行甄选，以及三角形和直线的位置关系，判断三角形是不是直角还是钝角还是锐角难度特大，题量特大。
第四次作业的第一题我学会了如何提取字符串中除了特定字符的剩余字符串用数字表示，如何使用一个字符串是否与给定的字符串一致，难度很小，题量很小。第二题我学会了如何判定是否为四边形和平行四边形，以及正方形，菱形和矩形，如何判断是凸四边形还是凹四边形，也学会了怎么判断double类型的数有几位小数，以及四舍五入指定位数，难度很大，题量很大。第三题我学会了如何使用多个类并且如何封装属性，理解了类与对象之间的关系，学会调用对象。难度适中，题量不大。
期中考试的第一题学会了怎么将数值保留几位小数，以及使用多个类并且如何封装属性，理解了类与对象和类与类之间的关系，学会调用对象，还学会了如何调用类中的私有属性，必须通过该类的构造函数的获得来得到该属性。难度适中，题量不大。第二题学会了怎么将数值保留几位小数，以及使用多个类并且如何封装属性，理解了类与对象和类与类之间的关系，以及怎么使用父类和父类与子类的关系(即继承关系)，学会在父类写什么东西，学会调用对象，还学会了如何调用类中的私有属性，必须通过该类的构造函数的获得来得到该属性。难度适中，题量较多。第三题学会了怎么将数值保留几位小数，以及使用多个类并且如何封装属性，理解了类与对象和类与类之间的关系，以及怎么使用父类和父类与子类的关系(即继承关系)，学会在父类写什么东西，学会调用对象，学会了如何使用容器保存类的对象以及进行相应的增删遍历操作还学会了如何调用类中的私有属性，必须通过该类的构造函数的获得来得到该属性。难度较大，题量较多。
第五次作业第一题学会了如何用正则表达式判断一个字符串是否为double类型，以及如何以，将字符内容分隔开和怎么以空格将点坐标分隔开，用Switch和case对情况进行甄选，学会了如何判断是否为五边形以及凹凸五边形，如何判断直线与五边形的位置关系。难度很大，题量很多。第二题学会了如何用正则表达式判断一个字符串是否为double类型，以及如何以，将字符内容分隔开和怎么以空格将点坐标分隔开，也学会了怎么判断double类型的数有几位小数，以及四舍五入指定位数，学会了如何输入五个点判断是否构成三角形和四边形和五边形以及怎么判断凹凸多变形，学会了如何判断直线与多边形的位置关系和多边形与多边形的位置关系，以及公共区域的面积，难度特别大，题量也很大。
第六次作业第一题学会了如何在规定的输入中怎么用正则表达式规范化，学会了抽象函数的注意事项和抽象函数与子类之间的关系，学会了如何使用Arraylist存储数据以及以及使用该数据和如何通过父类的Arraylist创建子类的Arraylist，学会如何使用迭代器排序以及引用date类规范时间格式，学会如何告诉年月日时分秒计算两时间的分钟差，子类中如何使用父类的属性和函数。难度很大，题量很多。第二题学会了如何使用接口，如何使用Arraylist存储数据以及使用该数据，初步认识Container容器。难度适中，题量适中。
第七次作业第一题学会了如何在规定的输入中怎么用正则表达式规范化，学会了抽象函数的注意事项和抽象函数与子类之间的关系，学会了如何使用Arraylist存储数据以及以及使用该数据和如何通过父类的Arraylist创建子类的Arraylist，学会如何使用迭代器排序以及引用date类规范时间格式，学会如何告诉年月日时分秒计算两时间的分钟差，子类中如何使用父类的属性和函数。难度很大，题量很多。第二题学会了如何使用Hashmap存储数据以及使用该数据，学会如何使用Arraylist存储数据，如何用list，如何用Collectios进行删除重复数据和按规定进行排序，且如何使用迭代器进行输出Hashmap里的数据。难度适中，题量适中。第三题学会了如何使用迭代器进行输出数据并且初步认识创建有序集合对象。难度较小，题量较小。
第八次作业第一题学会了如何在规定的输入中怎么用正则表达式规范化，学会了抽象函数的注意事项和抽象函数与子类之间的关系，学会了如何使用Arraylist存储数据以及以及使用该数据和如何通过父类的Arraylist创建子类的Arraylist，子类中如何使用父类的属性和函数。难度适中，题量适中。第二题学会了如何在类内创建类（即成员内部类），并且如何使用内部类里的属性和函数，并且如何创建内部类的对象。难度较小，题量较小。第三题学会了抽象类父类与其子类之间的关系和抽象类的注意事项。难度很小，题量好小。
设计与分析：第一次作业的第一题我的思路是先定义两个输入的浮点型变量sg,tz，以及定义浮点型变量BMI进行赋值BMI = tz/(sg*sg)，然后根据BMI的取值范围分别对应其操作。
第二题我的思路是定义个输入的浮点型变量zhi，chang，并且将 0.45359237和0.0254赋值给两个变量，然后再做运算输出结果。第三题我的思路是创建一个放置10个元素的数组，然后用for循环对每个元素进行输入以存储在数组中并且执行判断为奇数的操作，最终输出奇数之和。第四题我的思路是定义题目中要求的四个输入变量，然后作为购房次数的那个变量在取值范围内进行讨论，里面在房屋面积的那个变量进行讨论执行相应操作，在循环外再列式子最终将其输出。第五题我的思路是定义两个输入的整数型变量，分别对变量进行Switch case语句实行对应输出的结果。第六题我的思路定义一个可以输入一行的输入变量，先判断位数，如果不是8位，非法输入，如果是8位数，则再判断学院编号是否为01,02，03,20,其中之一，若不为，非法输入，若为，再判断从右到左依次两位数属于什么特定东西，输出特定东西。第七题我的思路是定义三个浮点型可输入的变量，如果此变量不在题目所给的范围内，输入非法，如果在所给的范围内，如果三条边不能构成三角形，输出一段，如果可以先判断是否为等边三角形，若是，输出一段，不是的话再判断是否为等腰三角形，是判断一下是否为直角三角形，是输出一段，不是输出一段，若不是等腰三角形，再判断是否为直角三角形，是和不是分别输出一段，最终输出结果。第八题我的思路是定义两个浮点数型的可输入变量，再定义一个不可输入的变量用上面两个变量关系赋值表示，如果那两个变量分别小于0，小于等于0，则非法输入，否则再用一个循环表示最终的差值是否小于0.01，最终输出结果。第九题我的思路是定义一个字符串变量赋值为空，然后遍历输入的字符串，当为0或1时和不是进行相应地操作。
第二次作业第一题我的思路是先定义一个可输入的字符串变量，定义一个古典变量，用循环访问字符串的每个字符，若在a与z或A与Z之间，则古典变量赋予一个类型，否则赋予相反类型，若不在，则非法输入，然后用古典变量作为if判断条件，进行大写字母转换数字或小写字母转换数字的情况执行相应的操作。第二题我的思路是定义一个可输入的字符串变量，用字符串的长度和正则表达式判断输入的合法性，若少于11位或者输入数据全1没有起始位，则输出null data，然后再用循环访问该字符串的每一个字符，若为0并且自start变量从0和1，该字符串的第start+10位则按要求输出，否则如果为1，在进行如下操作，再接着以判断里面的古典变量作为if执行接下来所对应的情况，最终得到输出结果。
PowerDesigner相应类图：
第三题我的思路是定义一个输入一整行的可输入的字符串，判断位数是否为8的倍数，不是非法输入，是的话定义一个n个的一维数组，并调用string函数截取当中的字符串进行讨论得到最终结果。
第三次作业的第一题我的思路是定义一个输入一整行的变量，调用 String函数将空格前的字符串提取以及空格后的字符串提取，并讨论是否有逗号以及逗号的个数，若逗号个数并不等于1并且空格数等于逗号数-1并且点输入都符合要求则为超过点的个数，若为1个逗号则再讨论两边是否为double类型的数，用正则表达式判断，但是符号+-得单独判断，若满足两个点，再计算他们的距离，此时得创建一个类联系他们，若不满足，则非法输入，除此之外都非法输入。
PowerDesigner相应类图：
第二题我的思路是定义一个输入一整行的变量，调用 String函数将空格前的字符串提取以及空格后的字符串提取，并讨论是否有逗号以及逗号的个数，若逗号个数并不等于题目要求输入点的个数并且空格数等于逗号数-1并且点输入都符合要求则为超过点的个数，若为输入点的个数个逗号则再讨论两边是否为double类型的数，用正则表达式判断，但是符号+-得单独判断，若满足，输出true，若不满足，则输出false，定义一个函数判断是否为一个点，再定义一个函数判断格式输入符不符合要求以及超出点的个数，再定义一个函数判断两条线段构成直线的位置关系，定义一个函数判断三个点是否在一条直线上，对于选项，用Switch和case进行筛选，现版本Java支持筛选字符串，然后将各个选项用split分离即可。
PowerDesigner相应类图：
第三题我的思路是定义一个输入一整行的变量，调用 String函数将空格前的字符串提取以及空格后的字符串提取，并讨论是否有逗号以及逗号的个数，若逗号个数并不等于题目要求输入点的个数并且空格数等于逗号数-1并且点输入都符合要求则为超过点的个数，若为输入点的个数个逗号则再讨论两边是否为double类型的数，用正则表达式判断，但是符号+-得单独判断，若满足，输出true，若不满足，则输出false，定义一个函数判断是否为一个点，再定义一个函数判断格式输入符不符合要求以及超出点的个数，再定义一个函数判断两条线段构成直线的位置关系，定义一个函数判断三个点是否在一条直线上，对于选项，用Switch和case进行筛选，现版本Java支持筛选字符串，然后将各个选项用split分离即可，然后分别定义函数做执行各选项的操作。
PowerDesigner相应类图：
第四次作业第一题我的思路是定义一个输入变量，遍历其中的各个字符，若字符介于‘0’或‘9’之间，比较的是ASCII码，则将字符变成数值，累加其和。然后输出和。第二题我的思路是定义一个输入一整行的变量，调用 String函数将空格前的字符串提取以及空格后的字符串提取，并讨论是否有逗号以及逗号的个数，若逗号个数并不等于题目要求输入点的个数并且空格数等于逗号数-1并且点输入都符合要求则为超过点的个数，若为输入点的个数个逗号则再讨论两边是否为double类型的数，用正则表达式判断，但是符号+-得单独判断，若满足，输出true，若不满足，则输出false，定义一个函数判断是否为一个点，再定义一个函数判断格式输入符不符合要求以及超出点的个数，再定义一个函数判断两条线段构成直线的位置关系，定义一个函数判断三个点是否在一条直线上，对于选项，用Switch和case进行筛选，现版本Java支持筛选字符串，然后将各个选项用split分离即可，然后分别定义函数做执行各选项的操作，定义函数是否为四边形，再定义一个一条直线与四边形的交点个数的函数等函数。
PowerDesigner相应类图:
第三题我的思路是定义两个类，一个是主类，一个是BankBusiness类。在BankBusiness类中定义私有变量name，password和balance，然后在类里面添加获得私有属性以及返回私有属性的函数，以及题目要求的各个函数即可，主函数则是定义一个变量为BankBusiness类的一个对象，再定义多个输入输入变量，交替于执行操作之中即可。
PowerDesigner相应类图：
第五次作业第一题我的思路是定义一个输入一整行的变量，调用 String函数将空格前的字符串提取以及空格后的字符串提取，并讨论是否有逗号以及逗号的个数，若逗号个数并不等于题目要求输入点的个数并且空格数等于逗号数-1并且点输入都符合要求则为超过点的个数，若为输入点的个数个逗号则再讨论两边是否为double类型的数，用正则表达式判断，但是符号+-得单独判断，若满足，输出true，若不满足，则输出false，定义一个函数判断是否为一个点，再定义一个函数判断格式输入符不符合要求以及超出点的个数，再定义一个函数判断两条线段构成直线的位置关系，定义一个函数判断三个点是否在一条直线上，对于选项，用Switch和case进行筛选，现版本Java支持筛选字符串，然后将各个选项用split分离即可，然后分别定义函数做执行各选项的操作，定义函数在输入五个点的情况下是否为五边形，四边形，三角形，再定义一个一条直线与多边形的交点个数的函数，再定义一个算多边形面积的函数，定义一个是否为凹凸多边形的函数。第二题我的思路是定义一个输入一整行的变量，调用 String函数将空格前的字符串提取以及空格后的字符串提取，并讨论是否有逗号以及逗号的个数，若逗号个数并不等于题目要求输入点的个数并且空格数等于逗号数-1并且点输入都符合要求则为超过点的个数，若为输入点的个数个逗号则再讨论两边是否为double类型的数，用正则表达式判断，但是符号+-得单独判断，若满足，输出true，若不满足，则输出false，定义一个函数判断是否为一个点，再定义一个函数判断格式输入符不符合要求以及超出点的个数，再定义一个函数判断两条线段构成直线的位置关系，定义一个函数判断三个点是否在一条直线上，对于选项，用Switch和case进行筛选，现版本Java支持筛选字符串，然后将各个选项用split分离即可，然后分别定义函数做执行各选项的操作，定义函数在输入五个点的情况下是否为五边形，四边形，三角形，再定义一个一条直线与多边形的交点个数的函数，再定义一个算多边形面积的函数，定义一个是否为凹凸多边形的函数，定义是否有公共区域函数以及公共面积函数等。由于第一二题我写的时候放一起了，所以总类图如下：
PowerDesigner相应类图：
期中考试第一题我的思路是定义三个类，一个主类，其余分别是Line类和Point类，在Point类中定义私有属性横纵坐标，再定义一个获得该值以及返回该值的函数，还有一个display函数。在Line类中定义私有属性两个点和颜色，再定义一个获得该点以及返回该点的函数，再定义一个获得该颜色以及返回该颜色的函数，还有一个display函数，主函数定义一个Line类的对象和两个Point类的对象，再进行相应操作。
PowerDesigner相应类图：
第二题我的思路是定义五个类，一个主类，其余分别是Line类和Point类和Plane类和父类Element类，在Point类中定义私有属性横纵坐标，再定义一个获得该值以及返回该值的函数，还有一个display函数。在Line类中定义私有属性两个点和颜色，再定义一个获得该点以及返回该点的函数，再定义一个获得该颜色以及返回该颜色的函数，在Plane类中定义私有属性颜色，再定义一个获得该颜色以及返回该颜色的函数还有一个display函数，在Element中定义一个dislplay函数里面不用写东西，主函数定义一个Line类的对象和两个Point类的对象和一个Plane类的对象和一个Element类的对象，再进行相应操作。
PowerDesigner相应类图：
第三题与第二题类似但是得用容器进行存储数据和编写。
PowerDesigner相应类图：
第六次作业第一题我的思路是创建除主类的其他11个类，其中ChargeRule类是CallChargeRule的父类，CallChargeRule类是LandPhoneInCityRule，LandPhoneInProvinceRule，LandPhoneInLandRule类的父类，用于计算开户用户所有相应通话市内，省内，省外（国内）的用户的费用，而ChargeMode类是LandlinePhoneCharging的父类，用于返回月租的钱以及计算开户用户所有通话的费用。CommunicationRecord类是CallRecord类的父类，用于获取开户用户通话的信息等，User类用于开户用户，UserRecords用于存储开户用户分别通话市内，省内，省外（国内）的用户的记录。
PowerDesigner相应类图：
第二题我的思路是创建一个接口与主类相连，接口包含存储面积和体积的两个容器，以及私有属性pi=3.1415926，还有两个构造抽象函数计算面积和体积并且返回，该接口包含Cylinder和Cube类，主函数就是引用这几个类的对象然后定义计算所有Cylinder和Cube类的对象的面积和体积和。
第七次作业第一题我的思路跟第六次作业第一题一样，无非就是多加了手机与市内省内和省外手机和座机通话以及座机与手机通话的相关类，做法与第六次作业第一题思路类同。
PowerDesigner相应类图：
第二题我的思路是创建一个学生类，包含id，姓名，年龄，性别私有属性，且类中创建构造函数和tostring函数返回该所有属性。然后在主类主函数先定义一个整数变量用于输入，再定义各学生类里的属性相关变量，创建一个学生类对象，创建一个HashMap<String, Student>的对象，用循环将学生类相关变量赋予以空格分开的输入，且用于学生类的构造函数，将id和此时学生类的对象加入到HashMap<String, Student>的对象，再创建一个List存储HashMap<String, Student>的对象中的value东西，再用Collections将数据排序输出数据处理之后的数据个数，再用迭代器输出各个数据的私有属性。第三题我的思路是在学生属性里加一个tostring函数返回该所有属性，用迭代器输出所有东西，与第二题中迭代器用法类似。
第八次作业第一题我的思路跟第六次作业第一题一样，无非就是不考虑市内省内和省外发消息的情况，做法与第六次作业第一题思路类同。
PowerDesigner相应类图：
第二题和第三题由于过于简单，所以不写思路。
踩坑心得和改进建议：第一次作业第一题边界值没有取，由于在eclipse中无影响，而pta不能得全分最后一次提交修改过来了，所以无法截图，如下图划横线即为边界值，每次情况都要加=
第一次作业第二题一开始写代码的时候全用了double结果部分正确，最后将double改为float后就写对了。如下图，类型不同，输出结果有差异
所以要求严格认识double和float带来的差异
第一次作业第三题无问题
第一次作业第四题也是同第二题一样为浮点数类型的问题，将double改为float后就可行了
第一次作业第五题没有问题
第一次作业第六题无问题
第一次作业第七题中判断三角形是否为直角三角形时若两边的平方和等于第三边的平方和是错误的，应该是两边的平方和减去第三边的平方和小于0。01才算，因为三边均为浮点数，有精确度。在eclipse无法展现他们的区别和部分正确以及全部正确，所以无法截图。
第一次作业第八题也是double类型和浮点数类型的问题，将变量全用浮点数表示即可，与第二题一样的情况。
第一次作业第九题无问题
第二次作业第一题无问题
第二次作业第二题会漏判断条件
第二次作业第三题无问题
第三次作业第一题和第二题和第三题由于未在Pta上交完所以无法截图分析问题，未对点的个数超过2个的情况进行判断。改进建议以代码形式发出
第一题源码
import java.util.Scanner;
public class Main {
public static boolean isNumeric(String str){
if(str.matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
{
if(str.charAt(0) =='0')
{
if(str.length() >= 2)
if(str.charAt(str.length() - 1) != '.')
if(str.substring(1,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
return false;
else
return true;
else
return false;
else
return true;
}
else
if(str.charAt(str.length() - 1) != '.')
return true;
else
return false;
}
else if(str.charAt(0) == '+'||str.charAt(0) == '-')
{
if(str.length() == 1)
return false;
else if(str.length() >= 3)
if(str.substring(1,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
if(str.charAt(1) =='0')
if(str.charAt(str.length() - 1) != '.')
if(str.substring(2,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
return false;
else
return true;
else
return false;
else
if(str.charAt(str.length() - 1) != '.')
return true;
else
return false;
else
return false;
else
if(str.substring(1,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
return true;
else
return false;
}
else
{
return false;
}
}
public static boolean point(String str1,String str2) {
if(isNumeric(str1) == true&&isNumeric(str2) == true)
return true;
else
return false;
}
public static boolean dhgs(String str) {
int cnt = 0;
for(int i = 0;i < str.length();i++) {
if(str.charAt(i) == ',') {
cnt++;
}
}
if(cnt == 1)
return true;
else
return false;
}
public static double distance(double x1,double y1,double x2,double y2){
double distance;
distance = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
return distance;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int cnt = 0;
double a,b,c,d;
String str = in.nextLine();
String[] s = str.split(" ");
if(s.length - 1 > 1) {
for(int i = 0;i < s.length;i++) {
if(dhgs(s[i]) == true&&s[i].split(",").length == 2&&point(s[i].split(",")[0],s[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s.length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s.length == 1)//考虑未输入也算点的个数错误，而输入未含空格的字符串则非法输入
if(str == "")//或者条件可以写为else if(str == null)
System.out.print("wrong number of points");
else
System.out.print("Wrong Format");
else if(s.length == 0)//考虑输入全是空格为非法输入
System.out.print("Wrong Format");
else {
for(int i = 0;i < s.length;i++) {
if(dhgs(s[i]) == true&&s[i].split(",").length == 2&&point(s[i].split(",")[0],s[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s.length) {
if(str.charAt(str.length() - 1) != ' ') {
a = Double.parseDouble(s[0].split(",")[0]);
b = Double.parseDouble(s[0].split(",")[1]);
c = Double.parseDouble(s[1].split(",")[0]);
d = Double.parseDouble(s[1].split(",")[1]);
System.out.print(distance(a,b,c,d));
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
in.close();
}
}
第二题源代码
import java.util.Scanner;
public class Main {
public static boolean isNumeric(String str){
if(str.matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
{
if(str.charAt(0) =='0')
{
if(str.length() >= 2)
if(str.charAt(str.length() - 1) != '.')
if(str.substring(1,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
return false;
else
return true;
else
return false;
else
return true;
}
else
if(str.charAt(str.length() - 1) != '.')
return true;
else
return false;
}
else if(str.charAt(0) == '+'||str.charAt(0) == '-')
{
if(str.length() == 1)
return false;
else if(str.length() >= 3)
if(str.substring(1,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
if(str.charAt(1) =='0')
if(str.charAt(str.length() - 1) != '.')
if(str.substring(2,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
return false;
else
return true;
else
return false;
else
if(str.charAt(str.length() - 1) != '.')
return true;
else
return false;
else
return false;
else
if(str.substring(1,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
return true;
else
return false;
}
else
{
return false;
}
}
public static boolean point(String str1,String str2) {
if(isNumeric(str1) == true&&isNumeric(str2) == true)
return true;
else
return false;
}
public static boolean dhgs(String str) {
int cnt = 0;
for(int i = 0;i < str.length();i++) {
if(str.charAt(i) == ',') {
cnt++;
}
}
if(cnt == 1)
return true;
else
return false;
}
public static double xielv(double x1,double y1,double x2,double y2) {
double xielv = (y2 - y1)/(x2 - x1);
return xielv;
}
public static void One(String str) {
int cnt = 0;
double a,b,c,d;
String[] s = str.split("1:");
if(s.length == 2) {
if(s[1].split(" ").length - 1 > 1) {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s[1].split(" ").length == 1||s[1].split(" ").length == 0)
System.out.print("Wrong Format");
else {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) != ' ') {
a = Double.parseDouble(s[1].split(" ")[0].split(",")[0]);
b = Double.parseDouble(s[1].split(" ")[0].split(",")[1]);
c = Double.parseDouble(s[1].split(" ")[1].split(",")[0]);
d = Double.parseDouble(s[1].split(" ")[1].split(",")[1]);
if(a == c)
if(b == d)
System.out.print("points coincide");
else
System.out.print("Slope does not exist");
else
System.out.print(xielv(a,b,c,d));
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
}
else if(s.length == 0)
System.out.print("wrong number of points");
else
System.out.print("Wrong Format");
}
public static void Two(String str){
int cnt = 0;
double a,b,c,d,e,f;
double czjl;
String[] s = str.split("2:");
if(s.length == 2) {
if(s[1].split(" ").length - 1 > 2||s[1].split(" ").length - 1 == 1) {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s[1].split(" ").length == 1||s[1].split(" ").length == 0)
System.out.print("Wrong Format");
else {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length){
if(str.charAt(str.length() - 1) != ' '){
a = Double.parseDouble(s[1].split(" ")[0].split(",")[0]);
b = Double.parseDouble(s[1].split(" ")[0].split(",")[1]);
c = Double.parseDouble(s[1].split(" ")[1].split(",")[0]);
d = Double.parseDouble(s[1].split(" ")[1].split(",")[1]);
e = Double.parseDouble(s[1].split(" ")[2].split(",")[0]);
f = Double.parseDouble(s[1].split(" ")[2].split(",")[1]);
if(c == e)
if(d == f)
System.out.print("points coincide");
else
System.out.print(Math.abs(a -c));
else{
czjl = Math.abs((xielv(c,d,e,f)*a - b + d - xielv(c,d,e,f)*c)/Math.sqrt(Math.pow(xielv(c,d,e,f), 2) + 1));
System.out.print(czjl);
}
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
}
else if(s.length == 0)
System.out.print("wrong number of points");
else
System.out.print("Wrong Format");
}
public static void Three(String str){
int cnt = 0;
double a,b,c,d,e,f;
String[] s = str.split("3:");
if(s.length == 2) {
if(s[1].split(" ").length - 1 > 2||s[1].split(" ").length - 1 == 1) {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s[1].split(" ").length == 1||s[1].split(" ").length == 0)
System.out.print("Wrong Format");
else {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length){
if(str.charAt(str.length() - 1) != ' '){
a = Double.parseDouble(s[1].split(" ")[0].split(",")[0]);
b = Double.parseDouble(s[1].split(" ")[0].split(",")[1]);
c = Double.parseDouble(s[1].split(" ")[1].split(",")[0]);
d = Double.parseDouble(s[1].split(" ")[1].split(",")[1]);
e = Double.parseDouble(s[1].split(" ")[2].split(",")[0]);
f = Double.parseDouble(s[1].split(" ")[2].split(",")[1]);
if((a == c&&b == d)||(a == e&&b == f)||(c == e&&d == f))
System.out.print("points coincide");
else
if((c - a)*(f - d) == (d - b)*(e - c))
System.out.print("true");
else
System.out.print("false");
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
}
else if(s.length == 0)
System.out.print("wrong number of points");
else
System.out.print("Wrong Format");
}
public static void Four(String str){
int cnt = 0;
double a,b,c,d,e,f,g,h;
String[] s = str.split("4:");
if(s.length == 2) {
if(s[1].split(" ").length - 1 > 3||s[1].split(" ").length - 1 == 1||s[1].split(" ").length - 1 == 2) {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s[1].split(" ").length == 1||s[1].split(" ").length == 0)
System.out.print("Wrong Format");
else {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length){
if(str.charAt(str.length() - 1) != ' '){
a = Double.parseDouble(s[1].split(" ")[0].split(",")[0]);
b = Double.parseDouble(s[1].split(" ")[0].split(",")[1]);
c = Double.parseDouble(s[1].split(" ")[1].split(",")[0]);
d = Double.parseDouble(s[1].split(" ")[1].split(",")[1]);
e = Double.parseDouble(s[1].split(" ")[2].split(",")[0]);
f = Double.parseDouble(s[1].split(" ")[2].split(",")[1]);
g = Double.parseDouble(s[1].split(" ")[3].split(",")[0]);
h = Double.parseDouble(s[1].split(" ")[3].split(",")[1]);
if((a == c&&b == d)||(e == g&&f == h))
System.out.print("points coincide");
else
if((c - a)*(f - d) == (d - b)*(e - c))
System.out.print("false");
else
if((c - a)*(h - d) == (d - b)*(g - c))
System.out.print("false");
else
if((c - a)*(h - f) == (d - b)*(g - e))
System.out.print("true");
else
System.out.print("false");
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
}
else if(s.length == 0)
System.out.print("wrong number of points");
else
System.out.print("Wrong Format");
}
public static void Five(String str){
int cnt = 0;
double a,b,c,d,e,f,g,h;
double jiaodianx,jiaodiany;
String[] s = str.split("5:");
if(s.length == 2) {
if(s[1].split(" ").length - 1 > 3||s[1].split(" ").length - 1 == 1||s[1].split(" ").length - 1 == 2) {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s[1].split(" ").length == 1||s[1].split(" ").length == 0)
System.out.print("Wrong Format");
else {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length){
if(str.charAt(str.length() - 1) != ' '){
a = Double.parseDouble(s[1].split(" ")[0].split(",")[0]);
b = Double.parseDouble(s[1].split(" ")[0].split(",")[1]);
c = Double.parseDouble(s[1].split(" ")[1].split(",")[0]);
d = Double.parseDouble(s[1].split(" ")[1].split(",")[1]);
e = Double.parseDouble(s[1].split(" ")[2].split(",")[0]);
f = Double.parseDouble(s[1].split(" ")[2].split(",")[1]);
g = Double.parseDouble(s[1].split(" ")[3].split(",")[0]);
h = Double.parseDouble(s[1].split(" ")[3].split(",")[1]);
if((a == c&&b == d)||(e == g&&f == h))
System.out.print("points coincide");
else
if((c - a)*(f - d) == (d - b)*(e - c))
if((c - a)*(h - d) == (d - b)*(g - c))
System.out.print("is coincident lines,have infinite intersection points");
else {
System.out.print(e + "," + f);
if(f >= Math.max(b,d)||f <= Math.min(b, d))
System.out.print(" false");
else
System.out.print(" true");
}
else
if((c - a)*(h - d) == (d - b)*(g - c)) {
System.out.print(g + "," + h);
if(h >= Math.max(b,d)||h <= Math.min(b, d))
System.out.print(" false");
else
System.out.print(" true");
}
else
if((c - a)*(h - f) == (d - b)*(g - e))
System.out.print("is parallel lines,have no intersection point");
else
if(a == c){
jiaodiany = xielv(e,f,g,h)*a + f - xielv(e,f,g,h)*e;
System.out.print(a + "," + jiaodiany);
if((jiaodiany >= Math.max(b, d)&&jiaodiany >= Math.max(f, h))||(jiaodiany <= Math.min(b, d)&&jiaodiany <= Math.min(f, h)))
System.out.print(" false");
else
System.out.print(" true");
}
else{
if(e == g){
jiaodiany = xielv(a,b,c,d)*e + b - xielv(a,b,c,d)*a;
System.out.print(e + "," + jiaodiany);
if((jiaodiany >= Math.max(b, d)&&jiaodiany >= Math.max(f, h))||(jiaodiany <= Math.min(b, d)&&jiaodiany <= Math.min(f, h)))
System.out.print(" false");
else
System.out.print(" true");
}
else{
jiaodianx = (f - xielv(e,f,g,h)*e - b + xielv(a,b,c,d)*a)/(xielv(a,b,c,d) - xielv(e,f,g,h));
jiaodiany = xielv(a,b,c,d)*jiaodianx + b - xielv(a,b,c,d)*a;
System.out.print(jiaodianx + "," + jiaodiany);
if((jiaodiany >= Math.max(b, d)&&jiaodiany >= Math.max(f, h))||(jiaodiany <= Math.min(b, d)&&jiaodiany <= Math.min(f, h)))
System.out.print(" false");
else
System.out.print(" true");
}
}
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
}
else if(s.length == 0)
System.out.print("wrong number of points");
else
System.out.print("Wrong Format");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
String str = in.nextLine();
if(str.length() >= 2) {
switch(str.substring(0, 2)) {
case "1:":One(str);
break;
case "2:":Two(str);
break;
case "3:":Three(str);
break;
case "4:":Four(str);
break;
case "5:":Five(str);
break;
default:System.out.print("Wrong Format");
}
}
else
System.out.print("Wrong Format");
in.close();
}
}
第三题源码
import java.util.Scanner;
import java.math.BigDecimal;
public class Main {
public static boolean isNumeric(String str){
if(str.matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
{
if(str.charAt(0) =='0')
{
if(str.length() >= 2)
if(str.charAt(str.length() - 1) != '.')
if(str.substring(1,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
return false;
else
return true;
else
return false;
else
return true;
}
else
if(str.charAt(str.length() - 1) != '.')
return true;
else
return false;
}
else if(str.charAt(0) == '+'||str.charAt(0) == '-')
{
if(str.length() == 1)
return false;
else if(str.length() >= 3)
if(str.substring(1,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
if(str.charAt(1) =='0')
if(str.charAt(str.length() - 1) != '.')
if(str.substring(2,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
return false;
else
return true;
else
return false;
else
if(str.charAt(str.length() - 1) != '.')
return true;
else
return false;
else
return false;
else
if(str.substring(1,str.length()).matches("[0-9]+[.]{0,1}[0-9]*[dD]{0,1}"))
return true;
else
return false;
}
else
{
return false;
}
}
public static boolean point(String str1,String str2) {
if(isNumeric(str1) == true&&isNumeric(str2) == true)
return true;
else
return false;
}
public static double jingque(double num) {
if((num+"").length()-(num+"").indexOf(".")-1 > 6) {
BigDecimal bg = new BigDecimal(num);
@SuppressWarnings("deprecation")
double f1 = bg.setScale(6, BigDecimal.ROUND_HALF_UP).doubleValue();
return f1;
}
else
return num;
}
public static boolean dhgs(String str) {
int cnt = 0;
for(int i = 0;i < str.length();i++) {
if(str.charAt(i) == ',') {
cnt++;
}
}
if(cnt == 1)
return true;
else
return false;
}
public static double xielv(double x1,double y1,double x2,double y2) {
double xielv = (y2 - y1)/(x2 - x1);
return xielv;
}
public static double distance(double x1,double y1,double x2,double y2){
double distance;
distance = Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
return distance;
}
public static void One(String str){
int cnt = 0;
double a,b,c,d,e,f;
String[] s = str.split("1:");
if(s.length == 2) {
if(s[1].split(" ").length - 1 > 2||s[1].split(" ").length - 1 == 1) {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s[1].split(" ").length == 1||s[1].split(" ").length == 0)
System.out.print("Wrong Format");
else {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length){
if(str.charAt(str.length() - 1) != ' '){
a = Double.parseDouble(s[1].split(" ")[0].split(",")[0]);
b = Double.parseDouble(s[1].split(" ")[0].split(",")[1]);
c = Double.parseDouble(s[1].split(" ")[1].split(",")[0]);
d = Double.parseDouble(s[1].split(" ")[1].split(",")[1]);
e = Double.parseDouble(s[1].split(" ")[2].split(",")[0]);
f = Double.parseDouble(s[1].split(" ")[2].split(",")[1]);
if(distance(a,b,c,d) + distance(c,d,e,f) > distance(a,b,e,f)&&distance(a,b,c,d) + distance(a,b,e,f) > distance(c,d,e,f)&&distance(c,d,e,f) + distance(a,b,e,f) > distance(a,b,c,d))
if(distance(a,b,c,d) == distance(c,d,e,f)||distance(a,b,c,d) == distance(a,b,e,f)||distance(c,d,e,f) == distance(a,b,e,f)) {
System.out.print("true");
if(distance(a,b,c,d) == distance(c,d,e,f)&&distance(a,b,c,d) == distance(a,b,e,f))
System.out.print(" true");
else
System.out.print(" false");
}
else
System.out.print("false" + " " + "false");
else{
System.out.print("data error");
}
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
}
else if(s.length == 0)
System.out.print("wrong number of points");
else
System.out.print("Wrong Format");
}
public static void Two(String str){
int cnt = 0;
double a,b,c,d,e,f;
double zc,mj,zxhzb,zxzzb;
String[] s = str.split("2:");
if(s.length == 2) {
if(s[1].split(" ").length - 1 > 2||s[1].split(" ").length - 1 == 1) {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s[1].split(" ").length == 1||s[1].split(" ").length == 0)
System.out.print("Wrong Format");
else {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length){
if(str.charAt(str.length() - 1) != ' '){
a = Double.parseDouble(s[1].split(" ")[0].split(",")[0]);
b = Double.parseDouble(s[1].split(" ")[0].split(",")[1]);
c = Double.parseDouble(s[1].split(" ")[1].split(",")[0]);
d = Double.parseDouble(s[1].split(" ")[1].split(",")[1]);
e = Double.parseDouble(s[1].split(" ")[2].split(",")[0]);
f = Double.parseDouble(s[1].split(" ")[2].split(",")[1]);
if(distance(a,b,c,d) + distance(c,d,e,f) > distance(a,b,e,f)&&distance(a,b,c,d) + distance(a,b,e,f) > distance(c,d,e,f)&&distance(c,d,e,f) + distance(a,b,e,f) > distance(a,b,c,d)) {
zc = distance(a,b,c,d) + distance(c,d,e,f) + distance(a,b,e,f);
mj = Math.sqrt((zc/2.0)*((zc/2.0)-distance(a,b,c,d))*((zc/2.0)-distance(c,d,e,f))*((zc/2.0)-distance(a,b,e,f)));
zxhzb = (a + c + e)/3.0;
zxzzb = (b + d + f)/3.0;
System.out.print(jingque(zc) + " " + jingque(mj) + " " + jingque(zxhzb) + "," + jingque(zxzzb));
}
else{
System.out.print("data error");
}
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
}
}
public static void Three(String str){
int cnt = 0;
double a,b,c,d,e,f;
String[] s = str.split("3:");
if(s.length == 2) {
if(s[1].split(" ").length - 1 > 2||s[1].split(" ").length - 1 == 1) {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s[1].split(" ").length == 1||s[1].split(" ").length == 0)
System.out.print("Wrong Format");
else {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length){
if(str.charAt(str.length() - 1) != ' '){
a = Double.parseDouble(s[1].split(" ")[0].split(",")[0]);
b = Double.parseDouble(s[1].split(" ")[0].split(",")[1]);
c = Double.parseDouble(s[1].split(" ")[1].split(",")[0]);
d = Double.parseDouble(s[1].split(" ")[1].split(",")[1]);
e = Double.parseDouble(s[1].split(" ")[2].split(",")[0]);
f = Double.parseDouble(s[1].split(" ")[2].split(",")[1]);
if(distance(a,b,c,d) + distance(c,d,e,f) > distance(a,b,e,f)&&distance(a,b,c,d) + distance(a,b,e,f) > distance(c,d,e,f)&&distance(c,d,e,f) + distance(a,b,e,f) > distance(a,b,c,d)) {
if(distance(a,b,c,d)*distance(a,b,c,d) + distance(c,d,e,f)*distance(c,d,e,f) == distance(a,b,e,f)*distance(a,b,e,f)||distance(a,b,c,d)*distance(a,b,c,d) + distance(a,b,e,f)*distance(a,b,e,f) == distance(c,d,e,f)*distance(c,d,e,f)||distance(a,b,e,f)*distance(a,b,e,f) + distance(c,d,e,f)*distance(c,d,e,f) == distance(a,b,c,d)*distance(a,b,c,d))
System.out.print("false" + " " + "true" + " "+ "false");
else if(distance(a,b,c,d)*distance(a,b,c,d) + distance(c,d,e,f)*distance(c,d,e,f) > distance(a,b,e,f)*distance(a,b,e,f)||distance(a,b,c,d)*distance(a,b,c,d) + distance(a,b,e,f)*distance(a,b,e,f) > distance(c,d,e,f)*distance(c,d,e,f)||distance(a,b,e,f)*distance(a,b,e,f) + distance(c,d,e,f)*distance(c,d,e,f) > distance(a,b,c,d)*distance(a,b,c,d))
System.out.print("true" + " " + "false" + " "+ "false");
else
System.out.print("false" + " " + "false" + " "+ "true");
}
else{
System.out.print("data error");
}
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
}
else if(s.length == 0)
System.out.print("wrong number of points");
else
System.out.print("Wrong Format");
}
public static void Four(String str){
int cnt = 0;
double a,b,c,d,e,f,g,h,j,k;
String[] s = str.split("4:");
if(s.length == 2) {
if(s[1].split(" ").length - 1 > 4||s[1].split(" ").length - 1 == 1||s[1].split(" ").length - 1 == 2||s[1].split(" ").length - 1 == 3) {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s[1].split(" ").length == 1||s[1].split(" ").length == 0)
System.out.print("Wrong Format");
else {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length){
if(str.charAt(str.length() - 1) != ' '){
a = Double.parseDouble(s[1].split(" ")[0].split(",")[0]);
b = Double.parseDouble(s[1].split(" ")[0].split(",")[1]);
c = Double.parseDouble(s[1].split(" ")[1].split(",")[0]);
d = Double.parseDouble(s[1].split(" ")[1].split(",")[1]);
e = Double.parseDouble(s[1].split(" ")[2].split(",")[0]);
f = Double.parseDouble(s[1].split(" ")[2].split(",")[1]);
g = Double.parseDouble(s[1].split(" ")[3].split(",")[0]);
h = Double.parseDouble(s[1].split(" ")[3].split(",")[1]);
j = Double.parseDouble(s[1].split(" ")[4].split(",")[0]);
k = Double.parseDouble(s[1].split(" ")[4].split(",")[1]);
if(a == c&&b == d)
if(distance(e,f,g,h) + distance(g,h,j,k) > distance(e,f,j,k)&&distance(e,f,g,h) + distance(e,f,j,k) > distance(g,h,j,k)&&distance(g,h,j,k) + distance(e,f,j,k) > distance(e,f,g,h))
System.out.print("points coincide");
else
System.out.print("points coincide and data error");
else
if(distance(e,f,g,h) + distance(g,h,j,k) > distance(e,f,j,k)&&distance(e,f,g,h) + distance(e,f,j,k) > distance(g,h,j,k)&&distance(g,h,j,k) + distance(e,f,j,k) > distance(e,f,g,h))
System.out.print("data error");
else
System.out.print("data error");
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
}
else if(s.length == 0)
System.out.print("wrong number of points");
else
System.out.print("Wrong Format");
}
public static void Five(String str){
int cnt = 0;
double a,b,c,d,e,f,g,h;
double jiaodianx,jiaodiany;
String[] s = str.split("5:");
if(s.length == 2) {
if(s[1].split(" ").length - 1 > 3||s[1].split(" ").length - 1 == 1||s[1].split(" ").length - 1 == 2) {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length) {
if(str.charAt(str.length() - 1) == ' ')//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数错误要求，实则输入非法的情况
System.out.print("Wrong Format");
else
System.out.print("wrong number of points");
}
}
else if(s[1].split(" ").length == 1||s[1].split(" ").length == 0)
System.out.print("Wrong Format");
else {
for(int i = 0;i < s[1].split(" ").length;i++) {
if(dhgs(s[1].split(" ")[i]) == true&&s[1].split(" ")[i].split(",").length == 2&&point(s[1].split(" ")[i].split(",")[0],s[1].split(" ")[i].split(",")[1]) == true)
cnt++;
else {
System.out.print("Wrong Format");
break;
}
}
if(cnt == s[1].split(" ").length){
if(str.charAt(str.length() - 1) != ' '){
a = Double.parseDouble(s[1].split(" ")[0].split(",")[0]);
b = Double.parseDouble(s[1].split(" ")[0].split(",")[1]);
c = Double.parseDouble(s[1].split(" ")[1].split(",")[0]);
d = Double.parseDouble(s[1].split(" ")[1].split(",")[1]);
e = Double.parseDouble(s[1].split(" ")[2].split(",")[0]);
f = Double.parseDouble(s[1].split(" ")[2].split(",")[1]);
g = Double.parseDouble(s[1].split(" ")[3].split(",")[0]);
h = Double.parseDouble(s[1].split(" ")[3].split(",")[1]);
if((a == c&&b == d)||(e == g&&f == h))
System.out.print("points coincide");
else
if((c - a)*(f - d) == (d - b)*(e - c))
if((c - a)*(h - d) == (d - b)*(g - c))
System.out.print("is coincident lines,have infinite intersection points");
else
System.out.print(e + "," + f + " false");
else
if((c - a)*(h - d) == (d - b)*(g - c))
System.out.print(g + "," + h + " false");
else
if((c - a)*(h - f) == (d - b)*(g - e))
System.out.print("is parallel lines,have no intersection point");
else
if(a == c){
jiaodiany = xielv(e,f,g,h)*a + f - xielv(e,f,g,h)*e;
System.out.print(a + "," + jiaodiany);
if(jiaodiany >= Math.max(b, d)||jiaodiany <= Math.min(b, d))
System.out.print(" false");
else
System.out.print(" true");
}
else{
if(e == g){
jiaodiany = xielv(a,b,c,d)*e + b - xielv(a,b,c,d)*a;
System.out.print(e + "," + jiaodiany);
if(jiaodiany >= Math.max(f, h)||jiaodiany <= Math.min(f, h))
System.out.print(" false");
else
System.out.print(" true");
}
else{
jiaodianx = (f - xielv(e,f,g,h)*e - b + xielv(a,b,c,d)*a)/(xielv(a,b,c,d) - xielv(e,f,g,h));
jiaodiany = xielv(a,b,c,d)*jiaodianx + b - xielv(a,b,c,d)*a;
System.out.print(jiaodianx + "," + jiaodiany);
if(jiaodiany >= Math.max(b, d)||jiaodiany >= Math.max(f, h)||jiaodiany <= Math.min(b, d)||jiaodiany <= Math.min(f, h))
System.out.print(" false");
else
System.out.print(" true");
}
}
}
else//考虑因输入时在最后一个点的坐标后面加上空格符号导致直观上符合点的个数与格式要求，实则输入非法的情况
System.out.print("Wrong Format");
}
}
}
else if(s.length == 0)
System.out.print("wrong number of points");
else
System.out.print("Wrong Format");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
String str = in.nextLine();
if(str.length() >= 2) {
switch(str.substring(0, 2)) {
case "1:":One(str);
break;
case "2:":Two(str);
break;
case "3:":Three(str);
break;
case "4:":Four(str);
break;
case "5:":Five(str);
break;
default:System.out.print("Wrong Format");
}
}
else
System.out.print("Wrong Format");
in.close();
}
}
第四次作业第一题和第三题无问题
第二题除了格式非法正确，其余操作错误，由于在PTA未交，所以无法截图
改进建议(以源码形式呈现)
第二题源码
import java.util.Scanner;
import java.util.ArrayList;
import java.text.DecimalFormat;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
String s = in.nextLine();
InputData d = new InputData();
ParseInput.paseInput(s, d);
int choice = d.getChoice();
ArrayList<Point> ps = d.getPoints();
switch (choice) {
case 1:
handle1(ps);
break;
case 2:
handle2(ps);
break;
case 3:
handle3(ps);
break;
case 4:
handle4(ps);
break;
case 5:
handle5(ps);
break;
}
in.close();
}
public static void handle1(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 4);
Quadrilateral q = new Quadrilateral(ps.get(0),ps.get(1),ps.get(2),ps.get(3));
q.setFourLines();
System.out.println(q.is_quadrilateral()+" "+q.is_parallelogram());
}
// 2；输入四个点坐标，判断是否是菱形、矩形、正方形，判断结果输出true/false，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
public static void handle2(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 4);
Quadrilateral q = new Quadrilateral(ps.get(0),ps.get(1),ps.get(2),ps.get(3));
q.setFourLines();
if(q.is_quadrilateral())
{
System.out.println(q.is_lozenge()+" "+q.is_rectangle()+" "+q.is_square());
}
else
{
System.out.println("not a quadrilateral");
}
}
// 3：输入四个点坐标，判断是凹四边形（false）还是凸四边形(true)，输出四边形周长、面积，结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形，输出"not a quadrilateral"
public static void handle3(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 4);
Quadrilateral q = new Quadrilateral(ps.get(0),ps.get(1),ps.get(2),ps.get(3));
q.setFourLines();
if(q.is_quadrilateral())
{
System.out.println(q.is_tuQuadrilateral()+" "+OutFormat.doubleFormat(q.getPerimeter())+" "+OutFormat.doubleFormat(q.getArea()));
}
else
{
System.out.println("not a quadrilateral");
}
}
public static void handle4(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 6);
Quadrilateral q = new Quadrilateral(ps.get(2),ps.get(3),ps.get(4),ps.get(5));
Line line = new Line(ps.get(0),ps.get(1));
if(q.is_Triangle()==null&&!q.is_quadrilateral())
{
System.out.println("not a quadrilateral or triangle");
System.exit(0);
}
else if(q.is_Triangle()!=null)
{
ArrayList<Point> list = q.is_Triangle();
Triangle t = new Triangle(list.get(0),list.get(1),list.get(2));
if(t.judgeLineCoincide(line))//与三角形的某一边重合的时候
{
System.out.println("The line is coincide with one of the lines");
System.exit(0);
}
else if(line.is_inOneline(t.pa, t.pb)&&line.is_inOneline(t.pa, t.pc))//没有交点，此时三个点位于直线一侧
{
System.out.println("0");
System.exit(0);
}
else if(line.is_inline(t.pa)&&line.is_inOneline(t.pb, t.pc)||line.is_inline(t.pb)&&line.is_inOneline(t.pa, t.pc)||
line.is_inline(t.pc)&&line.is_inOneline(t.pa, t.pb))//有一个交点，此时交与顶点，另外两点位于直线同侧
{
System.out.println("1");
System.exit(0);
}
else if(t.calArea(line) != 0)//有两个交点
{
System.out.println("2"+" "+OutFormat.doubleFormat(t.outArea(line)[0])+" "+OutFormat.doubleFormat(t.outArea(line)[1]));
System.exit(0);
}
}
else if(q.is_quadrilateral())
{
if(q.judgeLineCoincide(line))//与四边形的某一边重合的时候
{
System.out.println("The line is coincide with one of the lines");
System.exit(0);
}
else if(line.is_inOneline(q.p1, q.p2)&&line.is_inOneline(q.p1, q.p3)&&line.is_inOneline(q.p1, q.p4))//只有一个交点的时候
{
System.out.println("1");
System.exit(0);
}
else if(q.calArea(line) != 0)//有两个交点
{
System.out.println("2"+" "+OutFormat.doubleFormat(q.outArea(line)[0])+" "+OutFormat.doubleFormat(q.outArea(line)[1]));
System.exit(0);
}
}
}
public static void handle5(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 5);
Quadrilateral q = new Quadrilateral(ps.get(1),ps.get(2),ps.get(3),ps.get(4));
if(q.is_quadrilateral())
{
double s1 = Area.calculate(ps.get(0), ps.get(1),ps.get(2));
double s2 = Area.calculate(ps.get(0), ps.get(2),ps.get(3));
double s3 = Area.calculate(ps.get(0), ps.get(3),ps.get(4));
double s4 = Area.calculate(ps.get(0), ps.get(1),ps.get(4));
double s = Area.calculate(ps.get(1),ps.get(2),ps.get(3)) + Area.calculate(ps.get(1),ps.get(3),ps.get(4));
if(q.line1.is_inlineSegment(ps.get(0))||q.line2.is_inlineSegment(ps.get(0))||q.line3.is_inlineSegment(ps.get(0))||q.line4.is_inlineSegment(ps.get(0)))
{
System.out.println("on the quadrilateral");
System.exit(0);
}
else if(Math.abs(s-(s1+s2+s3+s4))<0.00000000001)
{
System.out.println("in the quadrilateral");
System.exit(0);
}
else
{
System.out.println("out of the quadrilateral");
System.exit(0);
}
}
else if(q.is_Triangle()!=null)
{
//计算
ArrayList<Point> list = q.is_Triangle();
Line lineA = new Line(list.get(0),list.get(1));
Line lineB = new Line(list.get(0),list.get(2));
Line lineC = new Line(list.get(1),list.get(2));
if(lineA.is_inlineSegment(ps.get(0))||lineB.is_inlineSegment(ps.get(0))||lineC.is_inlineSegment(ps.get(0))||
(list.get(0).equal(ps.get(0))||list.get(1).equal(ps.get(0))||list.get(2).equal(ps.get(0))))
{
System.out.println("on the triangle");
return;
}
else
{
if(Area.is_inArea(ps.get(0), list.get(0),list.get(1),list.get(2)))
{
System.out.println("in the triangle");
}
else
{
System.out.println("out of the triangle");
}
}
}
else
{
System.out.println("not a quadrilateral or triangle");
}
}
}
class Area {
public static double calculate(Point p1,Point p2, Point p3)
{
double a = p1.getDistance(p2);
double b = p2.getDistance(p3);
double c = p3.getDistance(p1);
double p = (a+b+c)/2;
double area = Math.sqrt(p*(p-a)*(p-b)*(p-c));
return area;
}
public static boolean is_inArea(Point p0,Point p1,Point p2, Point p3)
{
double s = Area.calculate(p1, p2, p3);
double s1 = Area.calculate(p0, p1, p2);
double s2 = Area.calculate(p0, p2, p3);
double s3 = Area.calculate(p0, p3, p1);
if(Math.abs(s1+s2+s3-s)<0.00000000001)
{
return true;
}
return false;
}
}
class InputData {
private int choice;;//用户输入的选择项
private ArrayList<Point> points = new ArrayList<Point>();//用户输入的点坐标
public int getChoice() {
return choice;
}
public void setChoice(int choice) {
this.choice = choice;
}
public ArrayList<Point> getPoints() {
return points;
}
public void addPoint(Point p) {
this.points.add(p);
}
}
class Line {
Point p1;
Point p2;
public Line(double x1, double y1, double x2, double y2) {
Point p1 = new Point(x1, y1);
Point p2 = new Point(x2, y2);
LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出
this.p1 = p1;
this.p2 = p2;
}
public Line(Point p1, Point p2) {
LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出
this.p1 = p1;
this.p2 = p2;
}
public boolean is_Slope()//判断斜率是否存在
{
if(p1.x==p2.x)
{
return false;
}
return true;
}
public double getSlope()//计算斜率
{
if(this.is_Slope())
{
double slope = 0;
slope = (p1.y-p2.y)/(p1.x-p2.x);
return slope;
}
return 0;
}
public boolean is_vertical(Line line)
{
if(this.is_Slope()&&line.is_Slope())
{
if(Math.abs(this.getSlope()*line.getSlope()-1)<0.0000001)
{
return true;
}
return false;
}
else if(!this.is_Slope()&&line.is_Slope())
{
if(line.getSlope()==0)
{
return true;
}
return false;
}
else if(!line.is_Slope()&&this.is_Slope())
{
if(this.getSlope()==0)
{
return true;
}
return false;
}
return false;
}
public double getDistance(Point p)//计算点到直线的距离
{
if(is_Slope())
{
double k = (p1.y-p2.y)/(p1.x-p2.x);
double b = p1.y-k*p1.x;
double d = (k*p.x+b-p.y)/(Math.sqrt(1+k*k));
return Math.abs(d);
}
else
{
return Math.abs(p.x-p1.x);
}
}
public boolean is_parallel(Line line)
{
if(is_Slope()&&line.is_Slope())
{
double k1 = getSlope();
double k2 = line.getSlope();
return ((Math.abs(k1-k2)<0.00001));
}
else if((!is_Slope()&&line.is_Slope())||(is_Slope()&&!line.is_Slope()))
{
return false;
}
else if(!is_Slope()&&!line.is_Slope())
{
return true;
}
else return false;
}
public boolean is_inline(Point p)//判断点是否在线上
{
if(p.equal(p1)||p.equal(p2))
{
return true;
}
Line line1 = new Line(p1,p);
Line line2 = new Line(p1,p2);
if(line1.is_Slope()&&line2.is_Slope())
{
if(Math.abs(line1.getSlope()-line2.getSlope())<0.0001)
{
return true;
}
}
else if(p1.x==p2.x&&p2.x==p.x)
{
return true;
}
return false;
}
public boolean is_inlineSegment(Point p)//判断是否在线段上
{
if (!this.is_inline(p)) {
return false;
}
if (p.equals(p1) || p.equals(p2)) {// 与端点重合，认为不在在两点之间,
return false;
}
double d = p2.getDistance(p1);
boolean b = p.getDistance(p2) < d && p.getDistance(p1) < d;
return b;
}
public boolean isCoincide(Line l) //两条线是否重合
{
if (!this.is_parallel(l)) {
return false;
}
if (this.is_inline(l.p1)) {
return true;
}
return false;
}
public Point intersection(Line line)//求两直线交点
{
Point p0 = new Point(0,0);
if(!is_parallel(line))
{
Point p3 = line.p1, p4 = line.p2;
double x_member, x_denominator, y_member, y_denominator;
x_denominator = p4.x * p2.y - p4.x * p1.y - p3.x * p2.y + p3.x * p1.y - p2.x * p4.y + p2.x * p3.y + p1.x * p4.y- p1.x * p3.y;
x_member = p3.y * p4.x * p2.x - p4.y * p3.x * p2.x - p3.y * p4.x * p1.x + p4.y * p3.x * p1.x- p1.y * p2.x * p4.x + p2.y * p1.x * p4.x + p1.y * p2.x * p3.x - p2.y * p1.x * p3.x;
if (x_denominator == 0)
p0.x = 0;
else
p0.x = x_member / x_denominator;
y_denominator = p4.y * p2.x - p4.y * p1.x - p3.y * p2.x + p1.x * p3.y - p2.y * p4.x + p2.y * p3.x + p1.y * p4.x- p1.y * p3.x;
y_member = -p3.y * p4.x * p2.y + p4.y * p3.x * p2.y + p3.y * p4.x * p1.y - p4.y * p3.x * p1.y+ p1.y * p2.x * p4.y - p1.y * p2.x * p3.y - p2.y * p1.x * p4.y + p2.y * p1.x * p3.y;
if (y_denominator == 0)
p0.y = 0;
else
p0.y = y_member / y_denominator;
}
return p0;
}
public boolean is_inOneline(Point p1,Point p2)//判断两个点是否在一条直线同侧
{
double d1 = (this.p2.x - this.p1.x) * (this.p1.y - p1.y) - (this.p2.y - this.p1.y) * (this.p1.x - p1.x);
double d2 = (this.p2.x - this.p1.x) * (this.p1.y - p2.y) - (this.p2.y - this.p1.y) * (this.p1.x - p2.x);
if(d1*d2 > 0)
{
return true;
}
return false;
}
}
class LineInputError {
// 直线的两点重合的错误判断和提示。
public static void pointsCoincideError(Point p1, Point p2) {
if ((p1.x == p2.x) && p1.y == p2.y) {
System.out.println("points coincide");
System.exit(0);
}
}
}
class OutFormat {
//按要求格式化实数的输出。
public static Double doubleFormat(double b) {
DecimalFormat df = new DecimalFormat("#.000");
Double output = Double.valueOf(df.format(b));
return output;
}
}
class ParseInput {
/*
* 输入：完整的输入字符串，包含选项和所有点的信息，格式：选项:x1,y1 x2,y2 .....xn,yn。选项只能是1-5
* 一个空InputData对象
* 处理：将输入字符串中的选项和点信息提取出来并设置到InputData对象中
* 输出：包含选项值和所有点的Point对象的InputData对象。
*/
public static void paseInput(String s, InputData d) {
PointInputError.wrongChoice(s);
d.setChoice(getChoice(s));
s = s.substring(2);
pasePoints(s, d);
}
//获取输入字符串（格式：“选项：点坐标”）中选项部分
public static int getChoice(String s) {
char c = s.charAt(0);
return c-48;
}
/*
* 输入：一个字符串，包含所有点的信息，格式：x1,y1 x2,y2 .....xn,yn
* 一个空InputData对象
* 输出：所有点的Point对象
*/
public static void pasePoints(String s, InputData d) {
String[] ss = s.split(" ");
if (ss.length == 0)
return;
for (int i = 0; i < ss.length; i++) {
d.addPoint(readPoint(ss[i]));
}
}
/*
* 输入：包含单个点信息的字符串，格式：x,y
* 输出：Point对象
*/
public static Point readPoint(String s) {
PointInputError.wrongPointFormat(s);
String[] ss = s.split(",");
double x = Double.parseDouble(ss[0]);
double y = Double.parseDouble(ss[1]);
// System.out.println("match");
return new Point(x, y);
}
}
class Point {
double x;
double y;
public Point() {}
public Point(double x, double y)
{
this.x = x;
this.y = y;
}
public double getDistance(Point p)//计算两点之间的距离
{
double distance = 0;
distance = Math.sqrt(Math.pow(this.x-p.x,2)+Math.pow(this.y-p.y,2));
return distance;
}
public boolean equal(Point p)//判断点是否重合
{
if(p.x==this.x&&p.y==this.y) {
return true;
}
else
{
return false;
}
}
public boolean onlyEqual(Point p2,Point p3,Point p4)//判断p是否只和p2重合
{
Point p1 = new Point(this.x,this.y);
if(p1.equal(p2)&&!p1.equal(p3)&&!p1.equal(p4))
{
return true;
}
return false;
}
}
class PointInputError {
//判断从字符串中解析出的点的数量是否合格。
public static void wrongNumberOfPoints(ArrayList<Point> ps, int num) {
if (ps.size() != num) {
System.out.println("wrong number of points");
System.exit(0);
}
}
//判断输入的字符串中点的坐标部分格式是否合格。若不符合，报错并退出程序
public static void wrongPointFormat(String s) {
if (!s.matches("[+-]?([1-9]\\d*|0)(\\.\\d+)?,[+-]?([1-9]\\d*|0)(\\.\\d+)?")) {
System.out.println("Wrong Format");
System.exit(0);
}
}
// 输入字符串是否是"选项:字符串"格式，选项部分是否是1~5其中之一
public static void wrongChoice(String s) {
if (!s.matches("[1-5]:.+")) {
System.out.println("Wrong Format");
System.exit(0);
}
}
}
class Quadrilateral {
Point p1;
Point p2;
Point p3;
Point p4;
Line line1;
Line line2;
Line line3;
Line line4;
public Quadrilateral(Point p1, Point p2, Point p3, Point p4) {
this.p1 = p1;
this.p2 = p2;
this.p3 = p3;
this.p4 = p4;
if(this.is_quadrilateral())
{
line1 = new Line(p1,p2);
line2 = new Line(p2,p3);
line3 = new Line(p3,p4);
line4 = new Line(p4,p1);
}
}
public void setFourLines()
{
line1 = new Line(p1,p2);
line2 = new Line(p2,p3);
line3 = new Line(p3,p4);
line4 = new Line(p4,p1);
}
public boolean judgeLineCoincide(Line line) {//判断前两个点组成的线是否与四边形重合
if(line.is_inline(p1)&&line.is_inline(p2)||line.is_inline(p2)&&line.is_inline(p3)||line.is_inline(p3)&&line.is_inline(p4)||line.is_inline(p4)&&line.is_inline(p1))
{
return true;
}
return false;
}
public ArrayList<Point> array()//将点打包成链表
{
ArrayList<Point> list = new ArrayList<Point>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
return list;
}
public boolean is_A_Point()//判断四点是否全部重合，此时为一个点
{
if(p1.equal(p2)&&p1.equal(p3)&&p1.equal(p4))
{
return true;
}
return false;
}
public boolean is_threePointEqual()//判断是否四个点中有三个重合的点，此时为直线
{
if(p1.equal(p2)&&p1.equal(p3)&&!p1.equal(p4)||p1.equal(p2)&&!p1.equal(p3)&&p1.equal(p4)||
!p1.equal(p2)&&p1.equal(p3)&&p1.equal(p4)||p2.equal(p3)&&p2.equal(p4)&&!p2.equal(p1))
{
return true;
}
return false;
}
public boolean is_noEqual()//判断是否没有重合的点,如果没有重合的点，则返回true，如果有重合的点，则返回false
{
if(p1.equal(p2)||p1.equal(p3)||p1.equal(p4)||p2.equal(p3)||p2.equal(p4)||p3.equal(p4))
{
return false;
}
return true;
}
/*
* 输入四个点，若有两个点重合，则返回新的ArrayList，若没有重合，则返回null
*/
public ArrayList<Point> twoPointEqual()//将四个点转化为三个点
{
ArrayList<Point> list = this.array();
if(p1.onlyEqual(p2, p3, p4)||p1.onlyEqual(p3, p2, p4)||p1.onlyEqual(p4, p2, p3))
{
list.remove(0);
return list;
}
else if(p2.onlyEqual(p3, p1, p4)||p2.onlyEqual(p4, p1, p3))
{
list.remove(1);
return list;
}
else if(p3.onlyEqual(p4, p1, p2))
{
list.remove(2);
return list;
}
else
{
return null;
}
}
public boolean is_fourPoiOneLine()
{
if(is_noEqual())
{
Line line1 = new Line(p1,p2);
if(line1.is_inline(p3)&&line1.is_inline(p4))
{
return true;
}
}
return false;
}
public ArrayList<Point> is_Triangle()//判断是否为三角形
{
if(twoPointEqual()!=null)//证明有两个点重合
{
ArrayList<Point> list = twoPointEqual();
Line line = new Line(list.get(0),list.get(1));
if(line.is_inline(list.get(2)))
{
return null;
}
return list;
}
else if(this.is_fourPoiOneLine())
{
return null;
}
else if(is_noEqual())//判断是否没有重合的点，如果没有，进入循环，如果有，不进入循环
{
ArrayList<Point> list = this.array();
Point p1 = list.get(0);
Point p2 = list.get(1);
Point p3 = list.get(2);
Point p4 = list.get(3);
Line line13 = new Line(p1,p3);
Line line24 = new Line(p2,p4);
if(line13.is_inlineSegment(p2))
{
list.remove(1);
}
else if(line24.is_inlineSegment(p3))
{
list.remove(2);
}
else if(line13.is_inlineSegment(p4))
{
list.remove(3);
}
else if(line24.is_inlineSegment(p1))
{
list.remove(0);
}
else
{
return null;
}
return list;
}
else
{
return null;
}
}
public boolean is_quadrilateral()//判断是否为四边形
{
if(this.is_A_Point())
{
return false;
}
else if(this.is_threePointEqual())
{
return false;
}
else if(this.twoPointEqual()!=null)
{
return false;
}
else if(this.is_Triangle()!=null)
{
return false;
}
else if(this.threePointOnLine(this.p1,this.p2,this.p3)||this.threePointOnLine(this.p1,this.p2,this.p4)||
this.threePointOnLine(this.p1,this.p3,this.p4)||this.threePointOnLine(this.p2,this.p3,this.p4))
{
return false;
}
else {
Line line12 = new Line(p1,p2);
Line line23 = new Line(p2,p3);
Line line34 = new Line(p3,p4);
Line line41 = new Line(p4,p1);
if(line23.is_inOneline(p1, p4)&&line12.is_inOneline(p3, p4)||line41.is_inOneline(p2, p3)&&line12.is_inOneline(p3, p4)
||line34.is_inOneline(p1, p2)&&line23.is_inOneline(p1, p4)||line41.is_inOneline(p2, p3)&&line34.is_inOneline(p1, p2))
{
return true;
}
return false;
}
}
private boolean threePointOnLine(Point p1,Point p2, Point p3) {
if(!p1.equal(p2))
{
Line line = new Line(p1,p2);
if(line.is_inline(p3))
{
return true;
}
return false;
}
return true;
}
public boolean is_parallelogram()//判断是否为平行四边形
{
if(is_quadrilateral())
{
if(line1.is_parallel(line3)&&(Math.abs(p1.getDistance(p2)-p3.getDistance(p4))<=0.0000001)||
line2.is_parallel(line4)&&(Math.abs(p2.getDistance(p3)-p4.getDistance(p1))<=0.0000001))
{
return true;
}
return false;
}
return false;
}
public boolean is_rectangle()//判断是否为矩形
{
if(is_parallelogram())
{
if(line1.is_vertical(line2))
{
return true;
}
return false;
}
return false;
}
public boolean is_lozenge()//判断是否为菱形
{
if(is_parallelogram())
{
if((Math.abs(p1.getDistance(p2)-p2.getDistance(p3))<=0.0000001))
{
return true;
}
return false;
}
return false;
}
public boolean is_square()//判断是否为正方形
{
if(is_lozenge())
{
if(line1.is_vertical(line2))
{
return true;
}
return false;
}
return false;
}
public boolean is_aoQuadrilateral()//判断是否为凹四边形
{
if(this.is_tuQuadrilateral())
{
return false;
}
return true;
}
public boolean is_tuQuadrilateral()//判断是否为凸四边形
{
double s1 = Area.calculate(p1,p2,p3)+Area.calculate(p3,p4,p1);
double s2 = Area.calculate(p2,p3,p4)+Area.calculate(p4,p1,p2);
if(Math.abs(s1-s2)<0.00000001)
{
return true;
}
return false;
}
public double getPerimeter()
{
double c = p1.getDistance(p2)+p2.getDistance(p3)+p3.getDistance(p4)+p4.getDistance(p1);
return c;
}
public double getArea()//计算四边形面积
{
if(is_tuQuadrilateral())
{
double s = Area.calculate(p1,p2,p3)+Area.calculate(p3,p4,p1);
return s;
}
else
{
double s1 = Area.calculate(p1,p2,p3)+Area.calculate(p3,p4,p1);
double s2 = Area.calculate(p2,p3,p4)+Area.calculate(p4,p1,p2);
double s = Math.min(s1, s2);
return s;
}
}
public double getAreaTu()
{
return Area.calculate(p1, p2, p3)+Area.calculate(p1, p3, p4);
}
public double calArea(Line line)
{
//过对角线
if(line.is_inline(p1)&&line.is_inline(p3))
{
double s = Area.calculate(p1, p2, p3);
return s;
}
else if(line.is_inline(p2)&&line.is_inline(p4))
{
double s = Area.calculate(p1, p2, p4);
return s;
}
//只过一个顶点
else if(line.is_inline(p1))
{
if(line2.is_inlineSegment(line.intersection(line2)))
{
double s = Area.calculate(p1, p2, line.intersection(line2));
return s;
}
else if(line3.is_inlineSegment(line.intersection(line3)))
{
double s = Area.calculate(p1, p4, line.intersection(line3));
return s;
}
}
else if(line.is_inline(p2))
{
if(line3.is_inlineSegment(line.intersection(line3)))
{
double s = Area.calculate(p2, p3, line.intersection(line3));
return s;
}
else if(line4.is_inlineSegment(line.intersection(line4)))
{
double s = Area.calculate(p1, p2, line.intersection(line4));
return s;
}
}
else if(line.is_inline(p3))
{
if(line1.is_inlineSegment(line.intersection(line1)))
{
double s = Area.calculate(p2, p3, line.intersection(line1));
return s;
}
else if(line4.is_inlineSegment(line.intersection(line4)))
{
double s = Area.calculate(p3, p4, line.intersection(line4));
return s;
}
}
else if(line.is_inline(p4))
{
if(line1.is_inlineSegment(line.intersection(line1)))
{
double s = Area.calculate(p1, p4, line.intersection(line1));
return s;
}
else if(line2.is_inlineSegment(line.intersection(line2)))
{
double s = Area.calculate(p3, p4, line.intersection(line2));
return s;
}
}
//不过顶点
//1.经过相邻两条边
else if(line1.is_inlineSegment(line.intersection(line1))&&line2.is_inlineSegment(line.intersection(line2)))
{
double s = Area.calculate(p2, line.intersection(line1), line.intersection(line2));
return s;
}
else if(line2.is_inlineSegment(line.intersection(line2))&&line3.is_inlineSegment(line.intersection(line3)))
{
double s = Area.calculate(p3, line.intersection(line2), line.intersection(line3));
return s;
}
else if(line3.is_inlineSegment(line.intersection(line3))&&line4.is_inlineSegment(line.intersection(line4)))
{
double s = Area.calculate(p4, line.intersection(line3), line.intersection(line4));
return s;
}
else if(line4.is_inlineSegment(line.intersection(line4))&&line1.is_inlineSegment(line.intersection(line1)))
{
double s = Area.calculate(p1, line.intersection(line4), line.intersection(line1));
return s;
}
//2.经过对边
else if(line1.is_inlineSegment(line.intersection(line1))&&line3.is_inlineSegment(line.intersection(line3)))
{
double s = Area.calculate(p1, line.intersection(line1), line.intersection(line3)) + Area.calculate(p4, p1,line.intersection(line3));
return s;
}
else if(line2.is_inlineSegment(line.intersection(line2))&&line4.is_inlineSegment(line.intersection(line4)))
{
double s = Area.calculate(p1, line.intersection(line2), line.intersection(line4)) + Area.calculate(p1, p2,line.intersection(line3));
return s;
}
return 0;
}
public double[] outArea(Line line) {
double s = this.getAreaTu();
double s1 = this.calArea(line);
double s2 = s-s1;
double area[] = {0,0};
if(s1>s2)
{
area[0] = s2;
area[1] = s1;
}
else
{
area[0] = s1;
area[1] = s2;
}
return area;
}
}
class Triangle {
Point pa;
Point pb;
Point pc;
Line lineA;
Line lineB;
Line lineC;
public Triangle(Point pa, Point pb, Point pc) {
this.pa = pa;
this.pb = pb;
this.pc = pc;
lineA = new Line(pb,pc);
lineB = new Line(pa,pc);
lineC = new Line(pa,pb);
}
/* 获取三角形的面积，此处采用海伦公式 */
public double getArea() {
return Area.calculate(pa,pb,pc);
}
//判断点p是否本三角形的顶点
public boolean isVertex(Point p) {
return p.equals(pa) || p.equals(pb) || p.equals(pc);
}
// 获取直线l与三角形的交点 并计算面积。
public double calArea(Line line) {
if(line.is_inline(pa)&&lineA.is_inlineSegment(line.intersection(lineA)))
{
double s = Area.calculate(pa, line.intersection(lineA), pb);
return s;
}
else if(line.is_inline(pb)&&lineB.is_inlineSegment(line.intersection(lineB)))
{
double s = Area.calculate(pb, line.intersection(lineB), pc);
return s;
}
else if(line.is_inline(pc)&&lineC.is_inlineSegment(line.intersection(lineC)))
{
double s = Area.calculate(pc, line.intersection(lineC), pa);
return s;
}
else if(lineA.is_inlineSegment(line.intersection(lineA))&&lineB.is_inlineSegment(line.intersection(lineB)))
{
double s = Area.calculate(line.intersection(lineA), line.intersection(lineB), pc);
return s;
}
else if(lineA.is_inlineSegment(line.intersection(lineA))&&lineC.is_inlineSegment(line.intersection(lineC)))
{
double s = Area.calculate(line.intersection(lineA), line.intersection(lineC), pb);
return s;
}
else if(lineC.is_inlineSegment(line.intersection(lineC))&&lineB.is_inlineSegment(line.intersection(lineB)))
{
double s = Area.calculate(line.intersection(lineC), line.intersection(lineB), pa);
return s;
}
else
{
return 0;
}
}
public float[] outArea(Line line) {
float s = (float)this.getArea();
float s1 = (float)this.calArea(line);
float s2 = s-s1;
float area[] = {0,0};
if(s1>s2)
{
area[0] = s2;
area[1] = s1;
}
else
{
area[0] = s1;
area[1] = s2;
}
return area;
}
// 判断线是否与三角形的某条边重合
public boolean judgeLineCoincide(Line line) {
if(line.is_inline(pa)&&line.is_inline(pb)||line.is_inline(pa)&&line.is_inline(pc)||line.is_inline(pb)&&line.is_inline(pc))
{
return true;
}
return false;
}
}
第五次作业第一题
计算之后的都不会写
第二题整道题0分，不会写
两道题改进建议附上源码
import static java.lang.Math.max;
import static java.lang.Math.min;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.HashSet;
import java.text.DecimalFormat;
public class Main {
static int choice;
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
String s = in.nextLine();
InputData d = new InputData();
ParseInput.paseInput(s, d);
choice = d.getChoice();
ArrayList<Point> ps = d.getPoints();
switch (choice) {
case 1:
handle1(ps);
break;
case 2:
handle2(ps);
break;
case 3:
handle3(ps);
break;
case 4:
handle4(ps);
break;
case 5:
handle5(ps);
break;
case 6:
handle6(ps);
break;
}
in.close();
}
public static int getChoice() {
return choice;
}
// 1：输入五个点坐标，判断是否是五边形，判断结果输出true/false
public static void handle1(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 5);
Pentagon w = new Pentagon(ps.get(0),ps.get(1),ps.get(2),ps.get(3),ps.get(4));
System.out.println(w.is_Pentagon());
}
// 2；输入五个点坐标，判断是凹五边形（false）还是凸五边形(true)，如果是凸五边形，则再输出五边形周长、面积，结果之间以一个英文空格符分隔。
// 若五个点坐标无法构成五边形，输出"not a pentagon"
public static void handle2(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 5);
Pentagon w = new Pentagon(ps.get(0),ps.get(1),ps.get(2),ps.get(3),ps.get(4));
if(w.is_Pentagon())
{
if(w.is_tuPentagon())
System.out.println(w.is_tuPentagon() + " " + OutFormat.doubleFormat(w.getPerimeter()) +" " + OutFormat.doubleFormat(w.getArea()));
else
System.out.println("false");
}
else
{
System.out.println("not a pentagon");
}
}
// 3：输入七个点坐标，前两个点构成一条直线，后五个点构成一个五边形、四边形或三角形，输出直线与五边形、四边形或三角形相交的交点数量。
// 如果交点有两个，再按面积从小到大输出被直线分割成两部分的面积（不换行）。若直线与多边形形的一条边线重合，
// 输出"The line is coincide with one of the lines"。若后五个点不符合五边形输入，若前两点重合，输出"points coincide"。
public static void handle3(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 7);
Pentagon w = new Pentagon(ps.get(2),ps.get(3),ps.get(4),ps.get(5),ps.get(6));
Line line = new Line(ps.get(0),ps.get(1));
if(!(w.is_Pentagon()||w.is_Quadrilateral()||w.is_Triangle()))
{
System.out.println("not a pentagon");
}
else if(w.is_Pentagon())
{
if(w.judgeLineCoincide(line))//与五边形的某一边重合的时候
{
System.out.println("The line is coincide with one of the lines");
System.exit(0);
}
else if(line.is_inOneline(w.p1, w.p2)&&line.is_inOneline(w.p1, w.p3)&&line.is_inOneline(w.p1, w.p4)&&line.is_inOneline(w.p1, w.p5))//没有交点，此时三个点位于直线一侧
{
System.out.println("0");
System.exit(0);
}
else if(w.fourPointsOneLine(line))//有一个交点，此时交与顶点，另外四点位于直线同侧
{
System.out.println("1");
System.exit(0);
}
else
{
System.out.println("2"+" "+OutFormat.doubleFormat(w.outArea(line)[0])+" "+OutFormat.doubleFormat(w.outArea(line)[1]));
System.exit(0);
}
}
else if(w.is_Quadrilateral())
{
ArrayList<Point> list = w.changeFourPoints();
Quadrilateral q = new Quadrilateral(list.get(0),list.get(1),list.get(2),list.get(3));
if(q.judgeLineCoincide(line))//与四边形的某一边重合的时候
{
System.out.println("The line is coincide with one of the lines");
System.exit(0);
}
else if(line.is_inOneline(q.p1, q.p2)&&line.is_inOneline(q.p1, q.p3)&&line.is_inOneline(q.p1, q.p4))//只有一个交点的时候
{
System.out.println("1");
System.exit(0);
}
else if(q.calArea(line) != 0)//有两个交点
{
System.out.println("2"+" "+OutFormat.doubleFormat(q.outArea(line)[0])+" "+OutFormat.doubleFormat(q.outArea(line)[1]));
System.exit(0);
}
}
else if(w.is_Triangle())
{
ArrayList<Point> list1 = w.changeFourPoints();
Quadrilateral q = new Quadrilateral(list1.get(0),list1.get(1),list1.get(2),list1.get(3));
ArrayList<Point> list = q.is_Triangle();
Triangle t = new Triangle(list.get(0),list.get(1),list.get(2));
if(t.judgeLineCoincide(line))//与三角形的某一边重合的时候
{
System.out.println("The line is coincide with one of the lines");
System.exit(0);
}
else if(line.is_inOneline(t.pa, t.pb)&&line.is_inOneline(t.pa, t.pc))//没有交点，此时三个点位于直线一侧
{
System.out.println("0");
System.exit(0);
}
else if(line.is_inline(t.pa)&&line.is_inOneline(t.pb, t.pc)||line.is_inline(t.pb)&&line.is_inOneline(t.pa, t.pc)||
line.is_inline(t.pc)&&line.is_inOneline(t.pa, t.pb))//有一个交点，此时交与顶点，另外两点位于直线同侧
{
System.out.println("1");
System.exit(0);
}
else if(t.calArea(line) != 0)//有两个交点
{
System.out.println("2"+" "+OutFormat.doubleFormat(t.outArea(line)[0])+" "+OutFormat.doubleFormat(t.outArea(line)[1]));
System.exit(0);
}
}
}
public static void handle4(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 10);
Pentagon w1 = new Pentagon(ps.get(0),ps.get(1),ps.get(2),ps.get(3),ps.get(4));
Pentagon w2 = new Pentagon(ps.get(5),ps.get(6),ps.get(7),ps.get(8),ps.get(9));
if(w1.is_Pentagon())
{
if(w2.is_Pentagon())
{
w1.contain(w2);
}
else if(w2.is_Quadrilateral())
{
ArrayList<Point> list = w2.changeFourPoints();
Quadrilateral q = new Quadrilateral(list.get(0),list.get(1),list.get(2),list.get(3));
w1.contain(q);
}
else if(w2.is_Triangle())
{
ArrayList<Point> list1 = w2.changeFourPoints();
Quadrilateral q = new Quadrilateral(list1.get(0),list1.get(1),list1.get(2),list1.get(3));
ArrayList<Point> list = q.is_Triangle();
Triangle t = new Triangle(list.get(0),list.get(1),list.get(2));
w1.contain(t);
}
}
else if(w1.is_Quadrilateral())
{
ArrayList<Point> list = w1.changeFourPoints();
Quadrilateral q1 = new Quadrilateral(list.get(0),list.get(1),list.get(2),list.get(3));
if(w1.is_Quadrilateral()&&w2.is_Pentagon())
{
q1.contain(w2);
}
else if(w1.is_Quadrilateral()&&w2.is_Quadrilateral())
{
ArrayList<Point> list2 = w2.changeFourPoints();
Quadrilateral q2 = new Quadrilateral(list2.get(0),list2.get(1),list2.get(2),list2.get(3));
q1.contain(q2);
}
else if(w1.is_Quadrilateral()&&w2.is_Triangle())
{
ArrayList<Point> list1 = w2.changeFourPoints();
Quadrilateral q2 = new Quadrilateral(list1.get(0),list1.get(1),list1.get(2),list1.get(3));
ArrayList<Point> list2 = q2.is_Triangle();
Triangle t = new Triangle(list2.get(0),list2.get(1),list2.get(2));
q1.contain(t);
}
}
else if(w1.is_Triangle())
{
ArrayList<Point> list1 = w1.changeFourPoints();
Quadrilateral q = new Quadrilateral(list1.get(0),list1.get(1),list1.get(2),list1.get(3));
ArrayList<Point> list = q.is_Triangle();
Triangle t1 = new Triangle(list.get(0),list.get(1),list.get(2));
if(w2.is_Pentagon())
{
t1.contain(w2);
}
else if(w2.is_Quadrilateral())
{
ArrayList<Point> list11 = w2.changeFourPoints();
Quadrilateral q2 = new Quadrilateral(list11.get(0),list11.get(1),list11.get(2),list11.get(3));
t1.contain(q2);
}
else if(w2.is_Triangle())
{
ArrayList<Point> list11 = w2.changeFourPoints();
Quadrilateral q1 = new Quadrilateral(list11.get(0),list11.get(1),list11.get(2),list11.get(3));
ArrayList<Point> list111 = q1.is_Triangle();
Triangle t2 = new Triangle(list111.get(0),list111.get(1),list111.get(2));
t1.contain(t2);
}
}
}
public static void handle5(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 10);
Pentagon w1 = new Pentagon(ps.get(0),ps.get(1),ps.get(2),ps.get(3),ps.get(4));
Pentagon w2 = new Pentagon(ps.get(5),ps.get(6),ps.get(7),ps.get(8),ps.get(9));
if(w1.is_Pentagon())
{
ArrayList<Point> list1 = new ArrayList<Point>(Arrays.asList(ps.get(0),ps.get(1),ps.get(2),ps.get(3),ps.get(4)));
Pentagon p = new Pentagon(ps.get(0),ps.get(1),ps.get(2),ps.get(3),ps.get(4));
if(w2.is_Pentagon())
{
//System.out.println(OutFormat.doubleFormat(w1.getArea()));
if(w1.is_coincides(w2))
{
double s = w1.getArea();
System.out.println(OutFormat.doubleFormat(s));
return;
}
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(ps.get(5),ps.get(6),ps.get(7),ps.get(8),ps.get(9)));
double s = Mediator.getArea(list1, list2);
System.out.println(OutFormat.doubleFormat(s));
}
else if(w2.is_Quadrilateral())
{
ArrayList<Point> list = w2.changeFourPoints();
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(list.get(0),list.get(1),list.get(2),list.get(3)));
//System.out.println(OutFormat.doubleFormat(new Quadrilateral(list.get(0),list.get(1),list.get(2),list.get(3)).getArea()));
//System.out.println(OutFormat.doubleFormat(w1.getArea()));
double s = Mediator.getArea(list1, list2);
System.out.println(OutFormat.doubleFormat(s));
}
else if(w2.is_Triangle())
{
ArrayList<Point> Qlist1 = w2.changeFourPoints();
Quadrilateral q = new Quadrilateral(Qlist1.get(0),Qlist1.get(1),Qlist1.get(2),Qlist1.get(3));
ArrayList<Point> list = q.is_Triangle();
ArrayList<Point> Qlist = w2.changeFourPoints();
Quadrilateral q2 = new Quadrilateral(Qlist.get(0),Qlist.get(1),Qlist.get(2),Qlist.get(3));
ArrayList<Point> listt = q2.is_Triangle();
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(listt.get(0),listt.get(1),listt.get(2)));
//System.out.println(OutFormat.doubleFormat(new Triangle(listt.get(0),listt.get(1),listt.get(2)).getArea()));
//System.out.println(OutFormat.doubleFormat(w1.getArea()));
double s = Mediator.getArea(list1, list2);
System.out.println(OutFormat.doubleFormat(s));
}
}
else if(w1.is_Quadrilateral())
{
ArrayList<Point> list = w1.changeFourPoints();
ArrayList<Point> list1 = new ArrayList<Point>(Arrays.asList(list.get(0),list.get(1),list.get(2),list.get(3)));
System.out.println(OutFormat.doubleFormat(new Quadrilateral(list.get(0),list.get(1),list.get(2),list.get(3)).getArea()));
// if(w2.is_Pentagon())
// {
// ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(ps.get(5),ps.get(6),ps.get(7),ps.get(8),ps.get(9)));
// //System.out.println(OutFormat.doubleFormat(w2.getArea()));
// double s = Mediator.getArea(list1, list2);
// System.out.println(OutFormat.doubleFormat(s));
// }
// else if(w2.is_Quadrilateral())
// {
// Quadrilateral q1 = new Quadrilateral(list.get(0),list.get(1),list.get(2),list.get(3));
// ArrayList<Point> list2 = w2.changeFourPoints();
// Quadrilateral q2 = new Quadrilateral(list2.get(0),list2.get(1),list2.get(2),list2.get(3));
// if(q1.is_coincides(q2))
// {
// double s = q1.getArea();
// System.out.println(OutFormat.doubleFormat(s));
// return;
// }
// ArrayList<Point> Qlist = w2.changeFourPoints();
// ArrayList<Point> list21 = new ArrayList<Point>(Arrays.asList(Qlist.get(0),Qlist.get(1),Qlist.get(2),Qlist.get(3)));
// //System.out.println(OutFormat.doubleFormat(new Quadrilateral(Qlist.get(0),Qlist.get(1),Qlist.get(2),Qlist.get(3)).getArea()));
// double s = Mediator.getArea(list1, list21);
// System.out.println(OutFormat.doubleFormat(s));
// }
// else if(w2.is_Triangle())
// {
// ArrayList<Point> Qlist = w2.changeFourPoints();
// Quadrilateral q = new Quadrilateral(Qlist.get(0),Qlist.get(1),Qlist.get(2),Qlist.get(3));
// ArrayList<Point> Tlist = q.is_Triangle();
// ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(Tlist.get(0),Tlist.get(1),Tlist.get(2)));
// //System.out.println(OutFormat.doubleFormat(new Triangle(Tlist.get(0),Tlist.get(1),Tlist.get(2)).getArea()));
// double s = Mediator.getArea(list1, list2);
// System.out.println(OutFormat.doubleFormat(s));
// }
}
else if(w1.is_Triangle())
{
ArrayList<Point> Qlist1 = w1.changeFourPoints();
Quadrilateral q = new Quadrilateral(Qlist1.get(0),Qlist1.get(1),Qlist1.get(2),Qlist1.get(3));
ArrayList<Point> list = q.is_Triangle();
ArrayList<Point> list1 = new ArrayList<Point>(Arrays.asList(list.get(0),list.get(1),list.get(2)));
Triangle t = new Triangle(list.get(0),list.get(1),list.get(2));
if(w2.is_Pentagon())
{
//System.out.println(OutFormat.doubleFormat(w2.getArea()));
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(ps.get(5),ps.get(6),ps.get(7),ps.get(8),ps.get(9)));
double s = Mediator.getArea(list1, list2);
System.out.println(OutFormat.doubleFormat(s));
}
else if(w2.is_Quadrilateral())
{
ArrayList<Point> Qlist = w2.changeFourPoints();
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(Qlist.get(0),Qlist.get(1),Qlist.get(2),Qlist.get(3)));
Quadrilateral q2 = new Quadrilateral(Qlist.get(0),Qlist.get(1),Qlist.get(2),Qlist.get(3));
//System.out.println(OutFormat.doubleFormat(q2.getArea()));
if(t.is_inside(q2))
{
System.out.println(OutFormat.doubleFormat(q2.getArea()));return;
}
double s = Mediator.getArea(list1, list2);
System.out.println(OutFormat.doubleFormat(s));
}
else if(w2.is_Triangle())
{
ArrayList<Point> Qlist = w2.changeFourPoints();
Quadrilateral q2 = new Quadrilateral(Qlist.get(0),Qlist.get(1),Qlist.get(2),Qlist.get(3));
ArrayList<Point> Tlist = q2.is_Triangle();
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(Tlist.get(0),Tlist.get(1),Tlist.get(2)));
Triangle t2 = new Triangle(Tlist.get(0),Tlist.get(1),Tlist.get(2));
//System.out.println(OutFormat.doubleFormat(t2.getArea()));
if(t.is_inside(t2))
{
System.out.println(OutFormat.doubleFormat(t2.getArea()));return;
}
double s = Mediator.getArea(list1, list2);
System.out.println(OutFormat.doubleFormat(s));
}
}
}
public static void handle6(ArrayList<Point> ps) {
PointInputError.wrongNumberOfPoints(ps, 6);
Pentagon w = new Pentagon(ps.get(1),ps.get(2),ps.get(3),ps.get(4),ps.get(5));
if(w.is_Pentagon())
{
if(w.line12.is_inlineSegment(ps.get(0))||w.line23.is_inlineSegment(ps.get(0))||w.line34.is_inlineSegment(ps.get(0))
||w.line45.is_inlineSegment(ps.get(0))||w.line51.is_inlineSegment(ps.get(0))||ps.get(0).equal(w.p1)||ps.get(0).equal(w.p2)
||ps.get(0).equal(w.p3)||ps.get(0).equal(w.p4)||ps.get(0).equal(w.p5))
{
System.out.println("on the pentagon");
System.exit(0);
}
else if(w.is_inArea(ps.get(0)))
{
System.out.println("in the pentagon");
System.exit(0);
}
else
{
System.out.println("out of the pentagon");
System.exit(0);
}
}
else if(w.is_Quadrilateral())
{
ArrayList<Point> list1 = w.changeFourPoints();
Quadrilateral q = new Quadrilateral(list1.get(0),list1.get(1),list1.get(2),list1.get(3));
if(q.line1.is_inlineSegment(ps.get(0))||q.line2.is_inlineSegment(ps.get(0))||q.line3.is_inlineSegment(ps.get(0))||q.line4.is_inlineSegment(ps.get(0))
||(list1.get(0).equal(ps.get(0))||list1.get(1).equal(ps.get(0))||list1.get(2).equal(ps.get(0))||list1.get(3).equal(ps.get(0))))
{
System.out.println("on the quadrilateral");
System.exit(0);
}
else if(q.is_inArea(ps.get(0)))
{
System.out.println("in the quadrilateral");
System.exit(0);
}
else
{
System.out.println("out of the quadrilateral");
System.exit(0);
}
}
else if(w.is_Triangle())
{
//计算
ArrayList<Point> list1 = w.changeFourPoints();
Quadrilateral q = new Quadrilateral(list1.get(0),list1.get(1),list1.get(2),list1.get(3));
ArrayList<Point> list = q.is_Triangle();
Triangle t = new Triangle(list.get(0),list.get(1),list.get(2));
if(t.lineA.is_inlineSegment(ps.get(0))||t.lineB.is_inlineSegment(ps.get(0))||t.lineC.is_inlineSegment(ps.get(0))||
(list.get(0).equal(ps.get(0))||list.get(1).equal(ps.get(0))||list.get(2).equal(ps.get(0))))
{
System.out.println("on the triangle");
return;
}
else if(t.is_inArea(ps.get(0)))
{
System.out.println("in the triangle");
}
else
{
System.out.println("out of the triangle");
}
}
else
{
System.out.println("not a quadrilateral or triangle");
}
}
}
class Area {
public static double calculate(Point p1,Point p2,Point p3)
{
double a = p1.getDistance(p2);
double b = p2.getDistance(p3);
double c = p3.getDistance(p1);
double p = (a+b+c)/2;
double area = Math.sqrt(p*(p-a)*(p-b)*(p-c));
return area;
}
}
class Contains {
public static ArrayList<Point> contains(ArrayList<Point> list1,ArrayList<Point> list2)
{
ArrayList<Point> list = new ArrayList<Point>();
if(list1.size() == 3)
{
Triangle t1 = new Triangle(list1.get(0),list1.get(1),list1.get(2)) ;
if(list2.size() == 3)
{
Triangle t2 = new Triangle(list2.get(0),list2.get(1),list2.get(2));
for(int i = 0;i < list2.size();i++)
{
if(t1.is_inArea(list2.get(i))) list.add(list2.get(i));
}
for(int i = 0;i < list1.size();i++)
{
if(t2.is_inArea(list1.get(i))) list.add(list1.get(i));
}
return list;
}
else if(list2.size() == 4)
{
Quadrilateral q2 = new Quadrilateral(list2.get(0),list2.get(1),list2.get(2),list2.get(3));
for(int i = 0;i < list2.size();i++)
{
if(t1.is_inArea(list2.get(i))) list.add(list2.get(i));
}
for(int i = 0;i < list1.size();i++)
{
if(q2.is_inArea(list1.get(i))) list.add(list1.get(i));
}
return list;
}
else if(list2.size() == 5)
{
Pentagon w2 = new Pentagon(list2.get(0),list2.get(1),list2.get(2),list2.get(3),list2.get(4));
for(int i = 0;i < list2.size();i++)
{
if(t1.is_inArea(list2.get(i))) list.add(list2.get(i));
}
for(int i = 0;i < list1.size();i++)
{
if(w2.is_inArea(list1.get(i))) list.add(list1.get(i));
}
return list;
}
}
else if(list1.size() == 4)
{
Quadrilateral q1 = new Quadrilateral(list1.get(0),list1.get(1),list1.get(2),list1.get(3));
if(list2.size() == 4)
{
Quadrilateral q2 = new Quadrilateral(list2.get(0),list2.get(1),list2.get(2),list2.get(3));
for(int i = 0;i < list2.size();i++)
{
if(q1.is_inArea(list2.get(i))) list.add(list2.get(i));
}
for(int i = 0;i < list1.size();i++)
{
if(q2.is_inArea(list1.get(i))) list.add(list1.get(i));
}
return list;
}
else if(list2.size() == 5)
{
Pentagon w2 = new Pentagon(list2.get(0),list2.get(1),list2.get(2),list2.get(3),list2.get(4));
for(int i = 0;i < list2.size();i++)
{
if(q1.is_inArea(list2.get(i))) list.add(list2.get(i));
}
for(int i = 0;i < list1.size();i++)
{
if(w2.is_inArea(list1.get(i))) list.add(list1.get(i));
}
return list;
}
}
else if(list1.size() == 5)
{
Pentagon w1 = new Pentagon(list1.get(0),list1.get(1),list1.get(2),list1.get(3),list1.get(4));
if(list1.size() == 5)
{
Pentagon w2 = new Pentagon(list2.get(0),list2.get(1),list2.get(2),list2.get(3),list2.get(4));
for(int i = 0;i < list2.size();i++)
{
if(w1.is_inArea(list2.get(i))) list.add(list2.get(i));
}
for(int i = 0;i < list1.size();i++)
{
if(w2.is_inArea(list1.get(i))) list.add(list1.get(i));
}
return list;
}
}
return null;
}
}
class GetIntersection {
public static ArrayList<Point> getIntersection(ArrayList<Point> list1, ArrayList<Point> list2) {
ArrayList<Point> list = new ArrayList<Point>(); // 两个多边形相交部分
Integer Num1 = list1.size(); // 多边形A的顶点个数
Integer Num2 = list2.size(); // 多边形B的顶点个数
// 添加A位于B中的所有顶点：循环A的所有顶点，判断是否位于B中
if(list1.size() < list2.size())
{
list = Contains.contains(list1, list2);
}
else
{
list = Contains.contains(list2, list1);
}
// 添加第一个顶点到末尾
list1.add(list1.get(0));
list2.add(list2.get(0));
// 添加A与B每一条边的交点：判断边与边是否相交，相交则求交点
boolean flag = false; // false为不相交，true为相交
for (int i = 0; i < Num1; i++) {
for (int j = 0; j < Num2; j++) {
// 判断多边形A的边(x1,y1)→(x2,y2)和多边形B的边(x3,y3)→(x4,y4)是否相交
double x1 = list1.get(i).x, y1 = list1.get(i).y; //list.get(i).x
double x2 = list1.get(i+1).x, y2 = list1.get(i+1).y;
double x3 = list2.get(j).x, y3 = list2.get(j).y;//list2.get(j).x
double x4 = list2.get(j+1).x, y4 = list2.get(j+1).y;
flag = isInterLines(x1, y1, x2, y2, x3, y3, x4, y4);
// 相交则求交点，并添加
if (flag) {
Point interSection = getInterSection(x1, y1, x2, y2, x3, y3, x4, y4);
list.add(new Point(interSection.x, interSection.y));
}
}
}
return list;
}
public static boolean isInterLines(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
if (max(x3, x4) < min(x1, x2) || max(x1, x2) < min(x3, x4)
|| max(y3, y4) < min(y1, y2) || max(y1, y2) < min(y3, y4)){
return false;
}
else {
if (((x2-x1)*(y4-y2) - (x4-x2)*(y2-y1)) * ((x2-x1)*(y3-y2) - (x3-x2)*(y2-y1)) < 0
&& ((x4-x1)*(y4-y3) - (x4-x3)*(y4-y1)) * ((x4-x2)*(y4-y3) - (x4-x3)*(y4-y2)) < 0) {
return true;
}
return false;
}
}
public static Point getInterSection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
double b1 = (y2 - y1) * x1 + (x1 - x2) * y1;
double b2 = (y4 - y3) * x3 + (x3 - x4) * y3;
double D = (x2 - x1) * (y4 - y3) - (x4 - x3) * (y2 - y1);
double D1 = b2 * (x2 - x1) - b1 * (x4 - x3);
double D2 = b2 * (y2 - y1) - b1 * (y4 - y3);
return new Point(D1 / D, D2 / D);
}
}
class GetIntersection {
public static ArrayList<Point> getIntersection(ArrayList<Point> list1, ArrayList<Point> list2) {
ArrayList<Point> list = new ArrayList<Point>(); // 两个多边形相交部分
Integer Num1 = list1.size(); // 多边形A的顶点个数
Integer Num2 = list2.size(); // 多边形B的顶点个数
// 添加A位于B中的所有顶点：循环A的所有顶点，判断是否位于B中
if(list1.size() < list2.size())
{
list = Contains.contains(list1, list2);
}
else
{
list = Contains.contains(list2, list1);
}
// 添加第一个顶点到末尾
list1.add(list1.get(0));
list2.add(list2.get(0));
// 添加A与B每一条边的交点：判断边与边是否相交，相交则求交点
boolean flag = false; // false为不相交，true为相交
for (int i = 0; i < Num1; i++) {
for (int j = 0; j < Num2; j++) {
// 判断多边形A的边(x1,y1)→(x2,y2)和多边形B的边(x3,y3)→(x4,y4)是否相交
double x1 = list1.get(i).x, y1 = list1.get(i).y; //list.get(i).x
double x2 = list1.get(i+1).x, y2 = list1.get(i+1).y;
double x3 = list2.get(j).x, y3 = list2.get(j).y;//list2.get(j).x
double x4 = list2.get(j+1).x, y4 = list2.get(j+1).y;
flag = isInterLines(x1, y1, x2, y2, x3, y3, x4, y4);
// 相交则求交点，并添加
if (flag) {
Point interSection = getInterSection(x1, y1, x2, y2, x3, y3, x4, y4);
list.add(new Point(interSection.x, interSection.y));
}
}
}
return list;
}
public static boolean isInterLines(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
if (max(x3, x4) < min(x1, x2) || max(x1, x2) < min(x3, x4)
|| max(y3, y4) < min(y1, y2) || max(y1, y2) < min(y3, y4)){
return false;
}
else {
if (((x2-x1)*(y4-y2) - (x4-x2)*(y2-y1)) * ((x2-x1)*(y3-y2) - (x3-x2)*(y2-y1)) < 0
&& ((x4-x1)*(y4-y3) - (x4-x3)*(y4-y1)) * ((x4-x2)*(y4-y3) - (x4-x3)*(y4-y2)) < 0) {
return true;
}
return false;
}
}
public static Point getInterSection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
double b1 = (y2 - y1) * x1 + (x1 - x2) * y1;
double b2 = (y4 - y3) * x3 + (x3 - x4) * y3;
double D = (x2 - x1) * (y4 - y3) - (x4 - x3) * (y2 - y1);
double D1 = b2 * (x2 - x1) - b1 * (x4 - x3);
double D2 = b2 * (y2 - y1) - b1 * (y4 - y3);
return new Point(D1 / D, D2 / D);
}
}
class InputData {
private int choice;;//用户输入的选择项
private ArrayList<Point> points = new ArrayList<Point>();//用户输入的点坐标
public int getChoice() {
return choice;
}
public void setChoice(int choice) {
this.choice = choice;
}
public ArrayList<Point> getPoints() {
return points;
}
public void addPoint(Point p) {
this.points.add(p);
}
}
class Line {
Point p1;
Point p2;
public Line(double x1, double y1, double x2, double y2) {
Point p1 = new Point(x1, y1);
Point p2 = new Point(x2, y2);
LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出
this.p1 = p1;
this.p2 = p2;
}
public Line(Point p1, Point p2) {
LineInputError.pointsCoincideError(p1, p2);//两点是否重合，重合则报错并退出
this.p1 = p1;
this.p2 = p2;
}
public boolean is_Slope()//判断斜率是否存在
{
if(p1.x==p2.x)
{
return false;
}
return true;
}
public double getSlope()//计算斜率
{
if(this.is_Slope())
{
double slope = 0;
slope = (p1.y-p2.y)/(p1.x-p2.x);
return slope;
}
return 0;
}
public boolean is_vertical(Line line)//判断两条线是否垂直
{
if(this.is_Slope()&&line.is_Slope())
{
if(Math.abs(this.getSlope()*line.getSlope()-1)<0.0000001)
{
return true;
}
return false;
}
else if(!this.is_Slope()&&line.is_Slope())
{
if(line.getSlope()==0)
{
return true;
}
return false;
}
else if(!line.is_Slope()&&this.is_Slope())
{
if(this.getSlope()==0)
{
return true;
}
return false;
}
return false;
}
public double getDistance(Point p)//计算点到直线的距离
{
if(is_Slope())
{
double k = (p1.y-p2.y)/(p1.x-p2.x);
double b = p1.y-k*p1.x;
double d = (k*p.x+b-p.y)/(Math.sqrt(1+k*k));
return Math.abs(d);
}
else
{
return Math.abs(p.x-p1.x);
}
}
//p1,p2是该线本身的两个端点
public boolean is_parallel(Line line)//判断两条线是否平行
{
if(is_Slope()&&line.is_Slope())
{
double k1 = getSlope();
double k2 = line.getSlope();
return ((Math.abs(k1-k2)<0.00001));
}
else if((!is_Slope()&&line.is_Slope())||(is_Slope()&&!line.is_Slope()))
{
return false;
}
else if(!is_Slope()&&!line.is_Slope())
{
return true;
}
else return false;
}
public boolean is_inline(Point p)//判断点是否在线上
{
if(p.equal(p1)||p.equal(p2))
{
return true;
}
Line line1 = new Line(p1,p);
Line line2 = new Line(p1,p2);
if(line1.is_Slope()&&line2.is_Slope())
{
if(Math.abs(line1.getSlope()-line2.getSlope())<0.0001)
{
return true;
}
}
else if(p1.x==p2.x&&p2.x==p.x)
{
return true;
}
return false;
}
public boolean is_inlineSegment(Point p)//判断是否在线段上
{
//System.out.println("isBetween" + " " + this.p1.x + " " + p1.y + " " + p2.x + " " + p2.y + " " + x.x + " " + x.y);
if (!this.is_inline(p)) {
return false;
}
// 与端点重合，认为不在在两点之间,
if (p.equals(p1) || p.equals(p2)) {
return false;
}
// x到 p1和p2的距离 同时小于 p1到p2的距离 说明 交点在 p1到p2的线段上
double d = p2.getDistance(p1);
boolean b = p.getDistance(p2) < d && p.getDistance(p1) < d;
//System.out.println("isBetween" + b);
return b;
}
public boolean isCoincide(Line l) //两条线是否重合
{
if (!this.is_parallel(l)) {
return false;
}
if (this.is_inline(l.p1)) {
return true;
}
return false;
}
public Point getIntersection(Line line)//求两直线交点
{
Point p0 = new Point();
if(!is_parallel(line))
{
if(!is_Slope()&&line.is_Slope())
{
p0.x = p1.x;
double k2 = line.getSlope();
double b2 = line.p1.y-k2*line.p1.x;
p0.y = k2*p0.x+b2;
}
else if(is_Slope()&&!line.is_Slope())
{
p0.x = line.p1.x;
double k1 = getSlope();
double b1 = p1.y-k1*p1.x;
p0.y = k1*p0.x+b1;
}
else
{
double k1 = getSlope();
double k2 = line.getSlope();
double b1 = p1.y-k1*p1.x;;
double b2 = line.p1.y-k2*line.p1.x;
p0.x = (b1-b2)/(k2-k1);
p0.y = (b1*k2-b2*k1)/(k2-k1);
}
}
return p0;
}
public boolean is_inOneline(Point p1,Point p2)//判断两个点是否在一条直线同侧
{
if(this.is_inline(p1)||this.is_inline(p2))
{
return false;
}
double d1 = (this.p2.x - this.p1.x) * (this.p1.y - p1.y) - (this.p2.y - this.p1.y) * (this.p1.x - p1.x);
double d2 = (this.p2.x - this.p1.x) * (this.p1.y - p2.y) - (this.p2.y - this.p1.y) * (this.p1.x - p2.x);
if(d1*d2 > 0)
{
return true;
}
return false;
}
public boolean equals(Line line)
{
if(this.is_inline(line.p1)&&this.is_inline(line.p2))
{
return true;
}
return false;
}
}
class LineInputError {
// 直线的两点重合的错误判断和提示。
public static void pointsCoincideError(Point p1, Point p2) {
if ((p1.x == p2.x) && p1.y == p2.y) {
System.out.println("points coincide");
System.exit(0);
}
}
}
class Mediator {
public static double getArea(ArrayList<Point> list1,ArrayList<Point> list2)
{
ArrayList<Point> list = GetIntersection.getIntersection(list1, list2);//求交点合集
HashSet<Point> hs = new HashSet<>(); //创建Set集合
hs.addAll(list); //把list集合中的元素添加到Set集合中
list.clear(); //清空list集合
list.addAll(hs); //把Set集合中（去掉重复的元素）放到list中
ArrayList<Point> sortlist = PolygonSort.PolygonClockwiseSort(list); //将交点排序
return PolygonGetArea.getArea(sortlist);//计算面积
}
}
class OutFormat {
//按要求格式化实数的输出。
public static Double doubleFormat(double b) {
DecimalFormat df = new DecimalFormat("#.000");
Double output = Double.valueOf(df.format(b));
return output;
}
}
class ParseInput {
public static void paseInput(String s, InputData d) {
PointInputError.wrongChoice(s);
d.setChoice(getChoice(s));
s = s.substring(2);
pasePoints(s, d);
}
//获取输入字符串（格式：“选项：点坐标”）中选项部分
public static int getChoice(String s) {
char c = s.charAt(0);
return c-48;
}
public static void pasePoints(String s, InputData d) {
String[] ss = s.split(" ");
if (ss.length == 0)
return;
for (int i = 0; i < ss.length; i++) {
d.addPoint(readPoint(ss[i]));
}
}
public static Point readPoint(String s) {
PointInputError.wrongPointFormat(s);
String[] ss = s.split(",");
double x = Double.parseDouble(ss[0]);
double y = Double.parseDouble(ss[1]);
// System.out.println("match");
return new Point(x, y);
}
}
class Pentagon {
Point p1;
Point p2;
Point p3;
Point p4;
Point p5;
Line line12 ;
Line line23 ;
Line line34 ;
Line line45 ;
Line line51 ;
public Pentagon(Point p1, Point p2, Point p3, Point p4, Point p5) {
this.p1 = p1;
this.p2 = p2;
this.p3 = p3;
this.p4 = p4;
this.p5 = p5;
if(is_Pentagon())
{
line12 = new Line(p1,p2);
line23 = new Line(p2,p3);
line34 = new Line(p3,p4);
line45 = new Line(p4,p5);
line51 = new Line(p5,p1);
}
}
public ArrayList<Point> array()//将点打包成链表
{
ArrayList<Point> list = new ArrayList<Point>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
list.add(p5);
return list;
}
public boolean is_Pentagon()//判断是否是五边形
{
Quadrilateral q1 = new Quadrilateral(p2,p3,p4,p5);
Quadrilateral q2 = new Quadrilateral(p1,p3,p4,p5);
Quadrilateral q3 = new Quadrilateral(p1,p2,p4,p5);
Quadrilateral q4 = new Quadrilateral(p1,p2,p3,p5);
Quadrilateral q5 = new Quadrilateral(p1,p2,p3,p4);
if(q1.is_quadrilateral()&&q2.is_quadrilateral()&&q3.is_quadrilateral()&&q4.is_quadrilateral()&&q5.is_quadrilateral())
{
return true;
}
else if(q1.is_quadrilateral()&&q1.is_inArea(p1)||q2.is_quadrilateral()&&q2.is_inArea(p2)||q3.is_quadrilateral()&&q3.is_inArea(p3)
||q4.is_quadrilateral()&&q4.is_inArea(p4)||q5.is_quadrilateral()&&q5.is_inArea(p5))
{
if(Main.getChoice() == 1||Main.getChoice() == 2||Main.getChoice() == 3)
return true;
else
return false;
}
return false;
}
public boolean is_squPentagon()
{
if(this.is_Pentagon())
{
if(Math.abs(p1.getDistance(p2)-p2.getDistance(p3))<=0.0000001&&Math.abs(p1.getDistance(p2)-p3.getDistance(p4))<=0.0000001
&&Math.abs(p1.getDistance(p2)-p4.getDistance(p5))<=0.0000001&&Math.abs(p1.getDistance(p5)-p5.getDistance(p1))<=0.0000001)
{
return true;
}
}
return false;
}
public boolean is_tuPentagon()
{
Quadrilateral q1 = new Quadrilateral(p2,p3,p4,p5);
Quadrilateral q2 = new Quadrilateral(p1,p3,p4,p5);
Quadrilateral q3 = new Quadrilateral(p1,p2,p4,p5);
Quadrilateral q4 = new Quadrilateral(p1,p2,p3,p5);
Quadrilateral q5 = new Quadrilateral(p1,p2,p3,p4);
if(q1.is_quadrilateral()&&q2.is_quadrilateral()&&q3.is_quadrilateral()&&q4.is_quadrilateral()&&q5.is_quadrilateral())
{
return true;
}
return false;
}
public boolean is_aoPentagon()
{
if(this.is_Pentagon())
{
if(this.is_tuPentagon())
{
return false;
}
return true;
}
return false;
}
public double getArea()
{
if(this.is_tuPentagon()||Main.getChoice() != 1&&Main.getChoice() != 2&&Main.getChoice() != 3)
{
return Area.calculate(p1, p2, p3) + Area.calculate(p1, p3, p4) + Area.calculate(p1, p4, p5);
}
return 0;
}
public double getPerimeter()
{
return p1.getDistance(p2) + p2.getDistance(p3) + p3.getDistance(p4) + p4.getDistance(p5) + p5.getDistance(p1);
}
/*
* 判断五个点是否可以转化为四个点
*/
public ArrayList<Point> changeFourPoints()//将五个点转化为四个点
{
ArrayList<Point> list = this.array();
//点重合情况
if(p1.equal(p2)) {if(new Quadrilateral(p2, p3, p4, p5).is_quadrilateral()) list.remove(0); else list.remove(1); return list;}
else if(p1.equal(p3)) {if(new Quadrilateral(p2, p3, p4, p5).is_quadrilateral()) list.remove(0); else list.remove(2); return list;}
else if(p1.equal(p4)) {if(new Quadrilateral(p2, p3, p4, p5).is_quadrilateral()) list.remove(0); else list.remove(3); return list;}
else if(p1.equal(p5)) {if(new Quadrilateral(p2, p3, p4, p5).is_quadrilateral()) list.remove(0); else list.remove(4); return list;}
else if(p2.equal(p3)) {if(new Quadrilateral(p1, p3, p4, p5).is_quadrilateral()) list.remove(1); else list.remove(2); return list;}
else if(p2.equal(p4)) {if(new Quadrilateral(p1, p3, p4, p5).is_quadrilateral()) list.remove(1); else list.remove(3); return list;}
else if(p2.equal(p5)) {if(new Quadrilateral(p1, p3, p4, p5).is_quadrilateral()) list.remove(1); else list.remove(4); return list;}
else if(p3.equal(p4)) {if(new Quadrilateral(p1, p2, p4, p5).is_quadrilateral()) list.remove(2); else list.remove(3); return list;}
else if(p3.equal(p5)) {if(new Quadrilateral(p1, p2, p4, p5).is_quadrilateral()) list.remove(2); else list.remove(4); return list;}
else if(p4.equal(p5)) {if(new Quadrilateral(p1, p2, p3, p5).is_quadrilateral()) list.remove(3); else list.remove(4); return list;}
//点在线上情况
else
{
Line line52 = new Line(p5,p2);
Line line13 = new Line(p1,p3);
Line line24 = new Line(p2,p4);
Line line35 = new Line(p3,p5);
Line line41 = new Line(p1,p4);
Line line51 = new Line(p5,p1);
Line line12 = new Line(p1,p2);
Line line23 = new Line(p2,p3);
Line line34 = new Line(p3,p4);
Line line45 = new Line(p4,p5);
if(line52.is_inlineSegment(p1))
{
list.remove(0);
return list;
}
else if(line13.is_inlineSegment(p2))
{
list.remove(1);
return list;
}
else if(line24.is_inlineSegment(p3))
{
list.remove(2);
return list;
}
else if(line35.is_inlineSegment(p4))
{
list.remove(3);
return list;
}
else if(line41.is_inlineSegment(p5))
{
list.remove(4);
return list;
}
}
return null;
}
public boolean is_Quadrilateral()
{
if(this.changeFourPoints() != null)
{
ArrayList<Point> list = this.changeFourPoints();
Quadrilateral q = new Quadrilateral(list.get(0),list.get(1),list.get(2),list.get(3));
if(q.is_quadrilateral())
{
return true;
}
}
return false;
}
public boolean is_Triangle()
{
if(this.changeFourPoints() != null)
{
ArrayList<Point> list = this.changeFourPoints();
Quadrilateral q = new Quadrilateral(list.get(0),list.get(1),list.get(2),list.get(3));
if(q.is_Triangle() != null)
{
return true;
}
}
return false;
}
public double calArea(Line line)
{
if(this.is_tuPentagon())
{
//过对角线
if(line.is_inline(p1)&&line.is_inline(p3))
{
double s = Area.calculate(p1, p2, p3);
return s;
}
else if(line.is_inline(p1)&&line.is_inline(p4))
{
double s = Area.calculate(p1, p4, p5);
return s;
}
else if(line.is_inline(p2)&&line.is_inline(p4))
{
double s = Area.calculate(p2, p3, p4);
return s;
}
else if(line.is_inline(p2)&&line.is_inline(p5))
{
double s = Area.calculate(p1, p2, p5);
return s;
}
else if(line.is_inline(p3)&&line.is_inline(p5))
{
double s = Area.calculate(p3, p4, p5);
return s;
}
//过一个顶点
else if(line.is_inline(p1))
{
if(line23.is_inlineSegment(line.getIntersection(line23)))
{
double s = Area.calculate(p1, p2, line.getIntersection(line23));
return s;
}
else if(line34.is_inlineSegment(line.getIntersection(line34)))
{
double s = new Quadrilateral(p1,p2,p3,line.getIntersection(line34)).getArea();
return s;
}
else if(line45.is_inlineSegment(line.getIntersection(line45)))
{
double s = Area.calculate(p1, p5, line.getIntersection(line45));
return s;
}
}
else if(line.is_inline(p2))
{
if(line34.is_inlineSegment(line.getIntersection(line34)))
{
double s = Area.calculate(p2, p3, line.getIntersection(line34));
return s;
}
else if(line45.is_inlineSegment(line.getIntersection(line45)))
{
double s = new Quadrilateral(p2,p3,p4,line.getIntersection(line45)).getArea();
return s;
}
else if(line51.is_inlineSegment(line.getIntersection(line51)))
{
double s = Area.calculate(p2, p1, line.getIntersection(line51));
return s;
}
}
else if(line.is_inline(p3))
{
if(line12.is_inlineSegment(line.getIntersection(line12)))
{
double s = Area.calculate(p2, p3, line.getIntersection(line12));
return s;
}
else if(line45.is_inlineSegment(line.getIntersection(line45)))
{
double s = Area.calculate(p3, p4, line.getIntersection(line45));
return s;
}
else if(line51.is_inlineSegment(line.getIntersection(line51)))
{
double s = new Quadrilateral(p3,p4,p5,line.getIntersection(line51)).getArea();;
return s;
}
}
else if(line.is_inline(p4))
{
if(line51.is_inlineSegment(line.getIntersection(line51)))
{
double s = Area.calculate(p5, p4, line.getIntersection(line51));
return s;
}
else if(line12.is_inlineSegment(line.getIntersection(line12)))
{
double s = new Quadrilateral(p4,p5,p1,line.getIntersection(line12)).getArea();
return s;
}
else if(line23.is_inlineSegment(line.getIntersection(line23)))
{
double s = Area.calculate(p3, p4, line.getIntersection(line23));
return s;
}
}
else if(line.is_inline(p5))
{
if(line12.is_inlineSegment(line.getIntersection(line12)))
{
double s = Area.calculate(p5, p1, line.getIntersection(line12));
return s;
}
else if(line23.is_inlineSegment(line.getIntersection(line23)))
{
double s = new Quadrilateral(p5,p1,p2,line.getIntersection(line23)).getArea();
return s;
}
else if(line34.is_inlineSegment(line.getIntersection(line34)))
{
double s = Area.calculate(p4, p5, line.getIntersection(line34));
return s;
}
}
//不过任何顶点
else if(line12.is_inlineSegment(line.getIntersection(line12))&&line51.is_inlineSegment(line.getIntersection(line51)))
{
double s = Area.calculate(p1, line.getIntersection(line12), line.getIntersection(line51));
return s;
}
else if(line12.is_inlineSegment(line.getIntersection(line12))&&line45.is_inlineSegment(line.getIntersection(line45)))
{
double s = new Quadrilateral(p1 , line.getIntersection(line12) , line.getIntersection(line45) , p5).getArea();
return s;
}
else if(line12.is_inlineSegment(line.getIntersection(line12))&&line34.is_inlineSegment(line.getIntersection(line34)))
{
double s = new Quadrilateral(line.getIntersection(line12) , p2 , p3 , line.getIntersection(line34)).getArea();
return s;
}
else if(line12.is_inlineSegment(line.getIntersection(line12))&&line23.is_inlineSegment(line.getIntersection(line23)))
{
double s = Area.calculate(line.getIntersection(line12), p2, line.getIntersection(line23));
return s;
}
else if(line23.is_inlineSegment(line.getIntersection(line23))&&line34.is_inlineSegment(line.getIntersection(line34)))
{
double s = Area.calculate(line.getIntersection(line23) , p3 , line.getIntersection(line34));
return s;
}
else if(line23.is_inlineSegment(line.getIntersection(line23))&&line45.is_inlineSegment(line.getIntersection(line45)))
{
double s = new Quadrilateral(line.getIntersection(line23) , p3 , p4 , line.getIntersection(line45)).getArea();
return s;
}
else if(line23.is_inlineSegment(line.getIntersection(line23))&&line51.is_inlineSegment(line.getIntersection(line51)))
{
double s = new Quadrilateral(p1 , p2 , line.getIntersection(line23) , line.getIntersection(line51)).getArea();
return s;
}
else if(line34.is_inlineSegment(line.getIntersection(line34))&&line45.is_inlineSegment(line.getIntersection(line45)))
{
double s = Area.calculate(line.getIntersection(line34) , p4 , line.getIntersection(line45));
return s;
}
else if(line34.is_inlineSegment(line.getIntersection(line34))&&line51.is_inlineSegment(line.getIntersection(line51)))
{
double s = new Quadrilateral(line.getIntersection(line34) , p4 , p5 , line.getIntersection(line51)).getArea();
return s;
}
else if(line45.is_inlineSegment(line.getIntersection(line45))&&line51.is_inlineSegment(line.getIntersection(line51)))
{
double s = Area.calculate(line.getIntersection(line45) , p5 , line.getIntersection(line51));
return s;
}
}
return 0;
}
public double[] outArea(Line line)
{
if(is_tuPentagon())
{
double s = this.getArea();
double s1 = this.calArea(line);
double s2 = s-s1;
double area[] = {0,0};
if(s1>s2)
{
area[0] = s2;
area[1] = s1;
}
else
{
area[0] = s1;
area[1] = s2;
}
return area;
}
return null;
}
public boolean is_inArea(Point p0)
{
double s1 = Area.calculate(p0, p1, p2);
double s2 = Area.calculate(p0, p2, p3);
double s3 = Area.calculate(p0, p3, p4);
double s4 = Area.calculate(p0, p4, p5);
double s5 = Area.calculate(p0, p5, p1);
double s = this.getArea();
if(Math.abs(s-(s1+s2+s3+s4+s5))<0.00000000001)
{
return true;
}
else
return false;
}
public boolean judgeLineCoincide(Line line) {//判断前两个点组成的线是否与四边形重合
if(line.is_inline(p1)&&line.is_inline(p2)||line.is_inline(p2)&&line.is_inline(p3)||line.is_inline(p3)&&line.is_inline(p4)
||line.is_inline(p4)&&line.is_inline(p5)||line.is_inline(p5)&&line.is_inline(p1))
{
return true;
}
return false;
}
public boolean fourPointsOneLine(Line line)
{
if(line.is_inOneline(p1, p2)&&line.is_inOneline(p1, p3)&&line.is_inOneline(p1, p4)&&line.is_inline(p5)
||line.is_inOneline(p1, p2)&&line.is_inOneline(p1, p3)&&line.is_inOneline(p1, p5)&&line.is_inline(p4)
||line.is_inOneline(p1, p2)&&line.is_inOneline(p1, p4)&&line.is_inOneline(p1, p5)&&line.is_inline(p3)
||line.is_inOneline(p1, p5)&&line.is_inOneline(p1, p3)&&line.is_inOneline(p1, p4)&&line.is_inline(p2)
||line.is_inOneline(p5, p2)&&line.is_inOneline(p5, p3)&&line.is_inOneline(p5, p4)&&line.is_inline(p1))
{
return true;
}
return false;
}
public boolean P_equals(Point p0)//判断一个点是否与四边形形四个顶点重合
{
if(this.p1.equal(p0)||this.p2.equal(p0)||this.p3.equal(p0)||this.p4.equal(p0)||this.p5.equal(p0))
{
return true;
}
return false;
}
public boolean is_coincides(Pentagon w)
{
if(this.P_equals(w.p1)&&this.P_equals(w.p2)&&this.P_equals(w.p3)&&this.P_equals(w.p4)&&this.P_equals(w.p5)) //重合
{
return true;
}
return false;
}
public void contain(Triangle t)
{
ArrayList<Point> list1 = new ArrayList<Point>(Arrays.asList(p1,p2,p3,p4,p5));
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(t.pa,t.pb,t.pc));
if(!this.is_inArea(t.pa)&&!this.is_inArea(t.pb)&&!this.is_inArea(t.pc)
&&!t.is_inArea(p1)&&!t.is_inArea(p2)&&!t.is_inArea(p3)&&!t.is_inArea(p4)&&t.is_inArea(p5))
{
System.out.println("no overlapping area between the pentagon the following triangle");
}
else if(Math.abs(Mediator.getArea(list1, list2))<0.00001)
{
System.out.println("the previous pentagon is connected to the following triangle");
}
else if(this.is_inArea(t.pa)&&this.is_inArea(t.pb)&&this.is_inArea(t.pc))
{
System.out.println("the previous pentagon contains the following triangle");
}
else if(t.is_inArea(p1)&&t.is_inArea(p2)&&t.is_inArea(p3)&&t.is_inArea(p4)&&t.is_inArea(p5))
{
System.out.println("the previous pentagon is inside the following triangle");
}
else
{
System.out.println("the previous pentagon is interlaced with the following triangle");
}
}
public void contain(Quadrilateral q)
{
ArrayList<Point> list1 = new ArrayList<Point>(Arrays.asList(p1,p2,p3,p4,p5));
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(q.p1,q.p2,q.p3,q.p4));
if(!this.is_inArea(q.p1)&&!this.is_inArea(q.p2)&&!this.is_inArea(q.p3)&&!this.is_inArea(q.p4)
&&!q.is_inArea(p1)&&!q.is_inArea(p2)&&!q.is_inArea(p3)&&!q.is_inArea(p4)&&!q.is_inArea(p5))
{
System.out.println("no overlapping area between the previous pentagon the following quadrilateral");
}
else if(Math.abs(Mediator.getArea(list1, list2))<0.00001)
{
System.out.println("the previous pentagon is connected to the following quadrilateral");
}
else if(this.is_inArea(q.p1)&&this.is_inArea(q.p2)&&this.is_inArea(q.p3)&&this.is_inArea(q.p4))
{
System.out.println("the previous pentagon contains the following quadrilateral");
}
else if(q.is_inArea(p1)&&q.is_inArea(p2)&&q.is_inArea(p3)&&q.is_inArea(p4)&&q.is_inArea(p5))
{
System.out.println("the previous pentagon is inside the following quadrilateral");
}
else
{
System.out.println("the previous pentagon is interlaced with the following quadrilateral");
}
}
public void contain(Pentagon w)
{
ArrayList<Point> list1 = new ArrayList<Point>(Arrays.asList(p1,p2,p3,p4,p5));
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(w.p1,w.p2,w.p3,w.p4,w.p5));
if(!this.is_inArea(w.p1)&&!this.is_inArea(w.p2)&&!this.is_inArea(w.p3)&&!this.is_inArea(w.p4)&&!this.is_inArea(w.p5)
&&!w.is_inArea(p1)&&!w.is_inArea(p2)&&!w.is_inArea(p3)&&!w.is_inArea(p4)&&!w.is_inArea(p5))
{
System.out.println("no overlapping area between the previous pentagon the following pentagon");
}
else if(this.P_equals(w.p1)&&this.P_equals(w.p2)&&this.P_equals(w.p3)&&this.P_equals(w.p4)&&this.P_equals(w.p5)) //重合
{
System.out.println("the previous pentagon coincides with the following pentagon");
}
else if(Math.abs(Mediator.getArea(list1, list2))<0.00001)//连接
{
System.out.println("the previous pentagon is connected to the following pentagon");
}
else if(this.is_inArea(w.p1)&&this.is_inArea(w.p2)&&this.is_inArea(w.p3)&&this.is_inArea(w.p4)&&this.is_inArea(w.p5))//包含
{
System.out.println("the previous pentagon contains the following pentagon");
}
else if(w.is_inArea(p1)&&w.is_inArea(p2)&&w.is_inArea(p3)&&w.is_inArea(p4)&&w.is_inArea(p5))//被包含
{
System.out.println("the previous pentagon is inside the following pentagon");
}
else
{
System.out.println("the previous pentagon is interlaced with the following pentagon");
}
}
}
class Point {
double x;
double y;
public Point() {}
public Point(double x, double y)
{
this.x = x;
this.y = y;
}
public Point(int x, int y)
{
this.x = x;
this.y = y;
}
public double getDistance(Point p)//计算两点之间的距离
{
double distance = 0;
distance = Math.sqrt(Math.pow(this.x-p.x,2)+Math.pow(this.y-p.y,2));
return distance;
}
public boolean equal(Point p)//判断点是否重合
{
if(p.x==this.x&&p.y==this.y) {
return true;
}
else
{
return false;
}
}
public boolean onlyEqual(Point p2,Point p3,Point p4)//判断p是否只和p2重合
{
Point p1 = new Point(this.x,this.y);
if(p1.equal(p2)&&!p1.equal(p3)&&!p1.equal(p4))
{
return true;
}
return false;
}
public boolean onlyEqual(Point p2,Point p3,Point p4,Point p5)//判断p是否只和p2重合
{
Point p1 = new Point(this.x,this.y);
if(p1.equal(p2)&&!p1.equal(p3)&&!p1.equal(p4)&&!p1.equal(p5))
{
return true;
}
return false;
}
public boolean onlyEqual(Point p2,Point p3,Point p4,Point p5,Point p6)//判断p是否只和p2重合
{
Point p1 = new Point(this.x,this.y);
if(p1.equal(p2)&&!p1.equal(p3)&&!p1.equal(p4)&&!p1.equal(p5)&&!p1.equal(p6))
{
return true;
}
return false;
}
}
class PointInputError {
public static void wrongNumberOfPoints(ArrayList<Point> ps, int num) {
if (ps.size() != num) {
System.out.println("wrong number of points");
System.exit(0);
}
}
public static void wrongPointFormat(String s) {
if (!s.matches("[+-]?([1-9]\\d*|0)(\\.\\d+)?,[+-]?([1-9]\\d*|0)(\\.\\d+)?")) {
System.out.println("Wrong Format");
System.exit(0);
}
}
public static void wrongChoice(String s) {
if (!s.matches("[1-6]:.+")) {
System.out.println("Wrong Format");
System.exit(0);
}
}
}
class PolygonGetArea {
public static double getArea(ArrayList<Point> list) {
double Area = 0; // 多边形的面积
Integer Num = list.size(); // 顶点个数
list.add(list.get(0));
for (int i = 0; i < Num; i++) {
Area += 0.5 * ((list.get(i).x * list.get(i+1).y) - (list.get(i).y * list.get(i+1).x));
}
return Math.abs(Area);
}
}
class PolygonSort {
public static ArrayList<Point> PolygonClockwiseSort(ArrayList<Point> list) {
Point center = PolygonSort.getCenter(list);
for (int i = 1; i < list.size(); i++) {
for (int j = 0; j < list.size() - i; j++) {
if (PointCmp(list.get(j), list.get(j+1), center)) {
Point tmp = new Point(list.get(j).x,list.get(j).y);
list.get(j).x = list.get(j+1).x;
list.get(j).y = list.get(j+1).y;
list.get(j+1).x = tmp.x;
list.get(j+1).y = tmp.y;
}
}
}
return list;
}
public static Point getCenter(ArrayList<Point> list) //计算多边形内点
{
int num = list.size();
double X = 0;
double Y = 0;
for (int i = 0; i < num; i++) {
X += list.get(i).x;
Y += list.get(i).y;
}
// 返回内点
Point center = new Point(X/num,Y/num);
return center;
}
public static boolean PointCmp(Point pointA, Point pointB, Point center)
{
double det = (pointA.x - center.x) * (pointB.y - center.y) - (pointB.x - center.x) * (pointA.y - center.y);
if (det > 0) {
return false;
}
else {
return true;
}
}
}
class Quadrilateral {
Point p1;
Point p2;
Point p3;
Point p4;
Line line1;
Line line2;
Line line3;
Line line4;
public Quadrilateral(Point p1, Point p2, Point p3, Point p4) {
this.p1 = p1;
this.p2 = p2;
this.p3 = p3;
this.p4 = p4;
if(this.is_quadrilateral())
{
line1 = new Line(p1,p2);
line2 = new Line(p2,p3);
line3 = new Line(p3,p4);
line4 = new Line(p4,p1);
}
}
public boolean judgeLineCoincide(Line line) {//判断前两个点组成的线是否与四边形重合
if(line.is_inline(p1)&&line.is_inline(p2)||line.is_inline(p2)&&line.is_inline(p3)||line.is_inline(p3)&&line.is_inline(p4)||line.is_inline(p4)&&line.is_inline(p1))
{
return true;
}
return false;
}
public boolean is_coincides(Quadrilateral q) {
if(this.P_equals(q.p1)&&this.P_equals(q.p2)&&this.P_equals(q.p3)&&this.P_equals(q.p4)) //重合
{
return true;
}
return false;
}
public double getArea() {
return Area.calculate(p1,p2,p3) + Area.calculate(p1,p3,p4);
}
public double calArea(Line line)
{
//过对角线
if(line.is_inline(p1)&&line.is_inline(p3))
{
double s = Area.calculate(p1, p2, p3);
return s;
}
else if(line.is_inline(p2)&&line.is_inline(p4))
{
double s = Area.calculate(p1, p2, p4);
return s;
}
//只过一个顶点
else if(line.is_inline(p1))
{
if(line2.is_inlineSegment(line.getIntersection(line2)))
{
double s = Area.calculate(p1, p2, line.getIntersection(line2));
return s;
}
else if(line3.is_inlineSegment(line.getIntersection(line3)))
{
double s = Area.calculate(p1, p4, line.getIntersection(line3));
return s;
}
}
else if(line.is_inline(p2))
{
if(line3.is_inlineSegment(line.getIntersection(line3)))
{
double s = Area.calculate(p2, p3, line.getIntersection(line3));
return s;
}
else if(line4.is_inlineSegment(line.getIntersection(line4)))
{
double s = Area.calculate(p1, p2, line.getIntersection(line4));
return s;
}
}
else if(line.is_inline(p3))
{
if(line1.is_inlineSegment(line.getIntersection(line1)))
{
double s = Area.calculate(p2, p3, line.getIntersection(line1));
return s;
}
else if(line4.is_inlineSegment(line.getIntersection(line4)))
{
double s = Area.calculate(p3, p4, line.getIntersection(line4));
return s;
}
}
else if(line.is_inline(p4))
{
if(line1.is_inlineSegment(line.getIntersection(line1)))
{
double s = Area.calculate(p1, p4, line.getIntersection(line1));
return s;
}
else if(line2.is_inlineSegment(line.getIntersection(line2)))
{
double s = Area.calculate(p3, p4, line.getIntersection(line2));
return s;
}
}
//不过顶点
//1.经过相邻两条边
else if(line1.is_inlineSegment(line.getIntersection(line1))&&line2.is_inlineSegment(line.getIntersection(line2)))
{
double s = Area.calculate(p2, line.getIntersection(line1), line.getIntersection(line2));
return s;
}
else if(line2.is_inlineSegment(line.getIntersection(line2))&&line3.is_inlineSegment(line.getIntersection(line3)))
{
double s = Area.calculate(p3, line.getIntersection(line2), line.getIntersection(line3));
return s;
}
else if(line3.is_inlineSegment(line.getIntersection(line3))&&line4.is_inlineSegment(line.getIntersection(line4)))
{
double s = Area.calculate(p4, line.getIntersection(line3), line.getIntersection(line4));
return s;
}
else if(line4.is_inlineSegment(line.getIntersection(line4))&&line1.is_inlineSegment(line.getIntersection(line1)))
{
double s = Area.calculate(p1, line.getIntersection(line4), line.getIntersection(line1));
return s;
}
//2.经过对边
else if(line1.is_inlineSegment(line.getIntersection(line1))&&line3.is_inlineSegment(line.getIntersection(line3)))
{
double s = Area.calculate(p1, line.getIntersection(line1), line.getIntersection(line3)) + Area.calculate(p4, p1,line.getIntersection(line3));
return s;
}
else if(line2.is_inlineSegment(line.getIntersection(line2))&&line4.is_inlineSegment(line.getIntersection(line4)))
{
double s = Area.calculate(p1, line.getIntersection(line2), line.getIntersection(line4)) + Area.calculate(p1, p2,line.getIntersection(line3));
return s;
}
return 0;
}
public double[] outArea(Line line) {
double s = this.getArea();
double s1 = this.calArea(line);
double s2 = s-s1;
double area[] = {0,0};
if(s1>s2)
{
area[0] = s2;
area[1] = s1;
}
else
{
area[0] = s1;
area[1] = s2;
}
return area;
}
public boolean is_inArea(Point p0)
{
if((line1.is_inlineSegment(p0)||line2.is_inlineSegment(p0)||line3.is_inlineSegment(p0)||line4.is_inlineSegment(p0)
||p0.equal(p1)||p0.equal(p2)||p0.equal(p3)||p0.equal(p4))&&((Main.getChoice() == 1)||(Main.getChoice() == 2)||(Main.getChoice() == 3)))
{
return false;
}
double s1 = Area.calculate(p0, p1,p2);
double s2 = Area.calculate(p0, p2,p3);
double s3 = Area.calculate(p0, p3,p4);
double s4 = Area.calculate(p0, p1,p4);
double s = Area.calculate(p1,p2,p3) + Area.calculate(p1,p3,p4);
if(Math.abs(s-(s1+s2+s3+s4))<0.00000000001)
{
return true;
}
else
return false;
}
public ArrayList<Point> array()//将点打包成链表
{
ArrayList<Point> list = new ArrayList<Point>();
list.add(p1);
list.add(p2);
list.add(p3);
list.add(p4);
return list;
}
public boolean is_A_Point()//判断四点是否全部重合，此时为一个点
{
if(p1.equal(p2)&&p1.equal(p3)&&p1.equal(p4))
{
return true;
}
return false;
}
public boolean is_threePointEqual()//判断是否四个点中有三个重合的点，此时为直线
{
if(p1.equal(p2)&&p1.equal(p3)&&!p1.equal(p4)||p1.equal(p2)&&!p1.equal(p3)&&p1.equal(p4)||
!p1.equal(p2)&&p1.equal(p3)&&p1.equal(p4)||p2.equal(p3)&&p2.equal(p4)&&!p2.equal(p1))
{
return true;
}
return false;
}
public boolean is_noEqual()//判断是否没有重合的点,如果没有重合的点，则返回true，如果有重合的点，则返回false
{
if(p1.equal(p2)||p1.equal(p3)||p1.equal(p4)||p2.equal(p3)||p2.equal(p4)||p3.equal(p4))
{
return false;
}
return true;
}
/*
* 输入四个点，若有两个点重合，则返回新的ArrayList，若没有重合，则返回null
*/
public ArrayList<Point> twoPointEqual()//将四个点转化为三个点
{
ArrayList<Point> list = this.array();
if(p1.onlyEqual(p2, p3, p4)||p1.onlyEqual(p3, p2, p4)||p1.onlyEqual(p4, p2, p3))
{
list.remove(0);
return list;
}
else if(p2.onlyEqual(p3, p1, p4)||p2.onlyEqual(p4, p1, p3))
{
list.remove(1);
return list;
}
else if(p3.onlyEqual(p4, p1, p2))
{
list.remove(2);
return list;
}
else
{
return null;
}
}
public boolean is_fourPoiOneLine()
{
if(is_noEqual())
{
Line line1 = new Line(p1,p2);
if(line1.is_inline(p3)&&line1.is_inline(p4))
{
return true;
}
}
return false;
}
/*
* 判断是否为三角形，若为三角形，则返回含三个点的ArrayList
* 若不是三角形，则返回null
*/
public ArrayList<Point> is_Triangle()//判断是否为三角形
{
if(twoPointEqual()!=null)//证明有两个点重合
{
ArrayList<Point> list = twoPointEqual();
Line line = new Line(list.get(0),list.get(1));
if(line.is_inline(list.get(2)))
{
return null;
}
return list;
}
else if(this.is_fourPoiOneLine())
{
return null;
}
else if(is_noEqual())//判断是否没有重合的点，如果没有，进入循环，如果有，不进入循环
{
ArrayList<Point> list = this.array();
Point p1 = list.get(0);
Point p2 = list.get(1);
Point p3 = list.get(2);
Point p4 = list.get(3);
Line line13 = new Line(p1,p3);
Line line24 = new Line(p2,p4);
if(line13.is_inlineSegment(p2))
{
list.remove(1);
}
else if(line24.is_inlineSegment(p3))
{
list.remove(2);
}
else if(line13.is_inlineSegment(p4))
{
list.remove(3);
}
else if(line24.is_inlineSegment(p1))
{
list.remove(0);
}
else
{
return null;
}
return list;
}
else
{
return null;
}
}
public boolean is_quadrilateral()//判断是否为四边形
{
if(this.is_A_Point()&&Main.getChoice() == 1&&Main.getChoice() == 2&&Main.getChoice() == 3) {
return false;
}
else if(this.is_threePointEqual())
{
return false;
}
else if(this.twoPointEqual()!=null)
{
return false;
}
else if(this.is_Triangle()!=null)
{
return false;
}
else if(this.threePointOnLine(this.p1,this.p2,this.p3)||this.threePointOnLine(this.p1,this.p2,this.p4)||
this.threePointOnLine(this.p1,this.p3,this.p4)||this.threePointOnLine(this.p2,this.p3,this.p4))
{
return false;
}
else {
Line line12 = new Line(p1,p2);
Line line23 = new Line(p2,p3);
Line line34 = new Line(p3,p4);
Line line41 = new Line(p4,p1);
if(line23.is_inOneline(p1, p4)&&line12.is_inOneline(p3, p4)||line41.is_inOneline(p2, p3)&&line12.is_inOneline(p3, p4)
||line34.is_inOneline(p1, p2)&&line23.is_inOneline(p1, p4)||line41.is_inOneline(p2, p3)&&line34.is_inOneline(p1, p2))
{
return true;
}
return false;
}
}
private boolean threePointOnLine(Point p1,Point p2, Point p3) {
if(!p1.equal(p2))
{
Line line = new Line(p1,p2);
if(line.is_inline(p3))
{
return true;
}
return false;
}
return true;
}
public boolean P_equals(Point p0)//判断一个点是否与四边形形四个顶点重合
{
if(this.p1.equal(p0)||this.p2.equal(p0)||this.p3.equal(p0)||this.p4.equal(p0))
{
return true;
}
return false;
}
public void contain(Triangle t)
{
int pcount = 0 ;
if(this.P_equals(t.pa)) pcount++;
if(this.P_equals(t.pb)) pcount++;
if(this.P_equals(t.pc)) pcount++;
if(!this.is_inArea(t.pa)&&!this.is_inArea(t.pb)&&!this.is_inArea(t.pc)
&&!t.is_inArea(p1)&&!t.is_inArea(p2)&&!t.is_inArea(p3)&&!t.is_inArea(p4))
{
System.out.println("no overlapping area between the previous quadrilateral and the following triangle");
}
else if(pcount==1)//连接
{
System.out.println("the previous quadrilateral is connected to the following triangle");
}
else if(this.is_inArea(t.pa)&&this.is_inArea(t.pb)&&this.is_inArea(t.pc))//包含
{
System.out.println("the previous quadrilateral contains the following triangle");
}
else if(t.is_inArea(p1)&&t.is_inArea(p2)&&t.is_inArea(p3)&&t.is_inArea(p4))//被包含
{
System.out.println("the previous quadrilateral is inside the following triangle");
}
else//分离
{
System.out.println("the previous quadrilateral is interlaced with the following triangle");
}
}
public void contain(Quadrilateral q)
{
int pcount = 0,lcount = 0;
if(this.P_equals(q.p1)) pcount++;
if(this.P_equals(q.p2)) pcount++;
if(this.P_equals(q.p3)) pcount++;
if(this.P_equals(q.p4)) pcount++;
if(!this.is_inArea(q.p1)&&!this.is_inArea(q.p2)&&!this.is_inArea(q.p3)&&!this.is_inArea(q.p4)
&&!q.is_inArea(p1)&&!q.is_inArea(p2)&&!q.is_inArea(p3)&&!q.is_inArea(p4))
{
System.out.println("no overlapping area between the previous quadrilateral and the following quadrilateral");
}
else if(this.P_equals(q.p1)&&this.P_equals(q.p2)&&this.P_equals(q.p3)&&this.P_equals(q.p4)) //重合
{
System.out.println("the previous quadrilateral coincides with the following quadrilateral");
}
else if(pcount==1)//连接
{
System.out.println("the previous quadrilateral is connected to the following quadrilateral");
}
else if(this.is_inArea(q.p1)&&this.is_inArea(q.p2)&&this.is_inArea(q.p3)&&this.is_inArea(q.p4))//包含
{
System.out.println("the previous quadrilateral contains the following quadrilateral");
}
else if(q.is_inArea(p1)&&q.is_inArea(p2)&&q.is_inArea(p3)&&q.is_inArea(p3))//被包含
{
System.out.println("the previous quadrilateral is inside the following quadrilateral");
}
else
{
System.out.println("the previous quadrilateral is interlaced with the following quadrilateral");
}
}
public void contain(Pentagon w)
{
int pcount = 0;
if(this.P_equals(w.p1)) pcount++;
if(this.P_equals(w.p2)) pcount++;
if(this.P_equals(w.p3)) pcount++;
if(this.P_equals(w.p4)) pcount++;
if(this.P_equals(w.p5)) pcount++;
if(!this.is_inArea(w.p1)&&!this.is_inArea(w.p2)&&!this.is_inArea(w.p3)&&!this.is_inArea(w.p4)&&!this.is_inArea(w.p5)
&&!w.is_inArea(p1)&&!w.is_inArea(p2)&&!w.is_inArea(p3)&&!w.is_inArea(p4))
{
System.out.println("no overlapping area between the previous quadrilateral and the following pentagon");
}
else if(pcount==1)//连接
{
System.out.println("the previous quadrilateral is connected to the following pentagon");
}
else if(this.is_inArea(w.p1)&&this.is_inArea(w.p2)&&this.is_inArea(w.p3)&&this.is_inArea(w.p4)&&this.is_inArea(w.p5))
{
System.out.println("the previous quadrilateral contains the following pentagon");
}
else if(w.is_inArea(p1)&&w.is_inArea(p2)&&w.is_inArea(p3)&&w.is_inArea(p4))
{
System.out.println("the previous quadrilateral is inside the following pentagon");
}
else
{
System.out.println("the previous quadrilateral is interlaced with the following pentagon");
}
}
}
class Triangle {
Point pa;
Point pb;
Point pc;
Line lineA;
Line lineB;
Line lineC;
public Triangle(Point pa, Point pb, Point pc) {
this.pa = pa;
this.pb = pb;
this.pc = pc;
lineA = new Line(pb,pc);
lineB = new Line(pa,pc);
lineC = new Line(pa,pb);
}
/* 获取三角形的面积，此处采用海伦公式 */
public double getArea() {
return Area.calculate(pa,pb,pc);
}
// 获取直线l与三角形的交点 并计算面积。
public double calArea(Line line) {
if(line.is_inline(pa)&&lineA.is_inlineSegment(line.getIntersection(lineA)))
{
double s = Area.calculate(pa, line.getIntersection(lineA), pb);
return s;
}
else if(line.is_inline(pb)&&lineB.is_inlineSegment(line.getIntersection(lineB)))
{
double s = Area.calculate(pb, line.getIntersection(lineB), pc);
return s;
}
else if(line.is_inline(pc)&&lineC.is_inlineSegment(line.getIntersection(lineC)))
{
double s = Area.calculate(pc, line.getIntersection(lineC), pa);
return s;
}
else if(lineA.is_inlineSegment(line.getIntersection(lineA))&&lineB.is_inlineSegment(line.getIntersection(lineB)))
{
double s = Area.calculate(line.getIntersection(lineA), line.getIntersection(lineB), pc);
return s;
}
else if(lineA.is_inlineSegment(line.getIntersection(lineA))&&lineC.is_inlineSegment(line.getIntersection(lineC)))
{
double s = Area.calculate(line.getIntersection(lineA), line.getIntersection(lineC), pb);
return s;
}
else if(lineC.is_inlineSegment(line.getIntersection(lineC))&&lineB.is_inlineSegment(line.getIntersection(lineB)))
{
double s = Area.calculate(line.getIntersection(lineC), line.getIntersection(lineB), pa);
return s;
}
else
{
return 0;
}
}
/*
* 计算三角形上两个点所切分出的两个区域的面积。
* 输入：在三角形三条边上的两个点，要求都不为null，且不在同一条边。
* 输入为null将会导致异常。
* 输出：两部分的面积，并按小-大的顺序排序。
*/
public double[] outArea(Line line) {
double s = this.getArea();
double s1 = this.calArea(line);
double s2 = s-s1;
double area[] = {0,0};
if(s1>s2)
{
area[0] = s2;
area[1] = s1;
}
else
{
area[0] = s1;
area[1] = s2;
}
return area;
}
// 判断线是否与三角形的某条边重合
public boolean judgeLineCoincide(Line line) {
if(line.is_inline(pa)&&line.is_inline(pb)||line.is_inline(pa)&&line.is_inline(pc)||line.is_inline(pb)&&line.is_inline(pc))
{
return true;
}
return false;
}
public boolean is_inArea(Point p0)
{
double s = Area.calculate(pa, pb, pc);
double s1 = Area.calculate(p0, pa, pc);
double s2 = Area.calculate(p0, pb, pc);
double s3 = Area.calculate(p0, pc, pa);
if(Math.abs(s1+s2+s3-s)<0.00000000001)
{
return true;
}
return false;
}
public boolean is_inOneLine(Point p0)//判断该点是否位于三角形的三条边上
{
if(lineA.is_inlineSegment(p0)||lineB.is_inlineSegment(p0)||lineC.is_inlineSegment(p0)
||pa.equal(p0)||pb.equal(p0)||pb.equal(p0))
{
return true;
}
return false;
}
public boolean P_equals(Point p0)//判断一个点是否与三角形三个顶点重合
{
if(this.pa.equal(p0)||this.pb.equal(p0)||this.pc.equal(p0))
{
return true;
}
return false;
}
public void contain(Triangle t)
{
ArrayList<Point> list1 = new ArrayList<Point>(Arrays.asList(pa,pb,pc));
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(t.pa,t.pb,t.pc));
if(!this.is_inArea(t.pa)&&!this.is_inArea(t.pb)&&!this.is_inArea(t.pc)
&&!t.is_inArea(pa)&&!t.is_inArea(pb)&&!t.is_inArea(pc))//分离
{
System.out.println("no overlapping area between the previous triangle and the following triangle");
}
else if(Math.abs(Mediator.getArea(list1, list2))<0.00001) //连接
{
System.out.println("the previous triangle is connected to the following triangle");
}
else if(this.P_equals(t.pa)&&this.P_equals(t.pb)&&this.P_equals(t.pc)) //重合
{
System.out.println("the previous triangle coincides with the following triangle");
}
else if(t.is_inArea(pa)&&t.is_inArea(pb)&&t.is_inArea(pc))//被包含
{
System.out.println("the previous triangle is inside the following triangle");
}
else if(this.is_inArea(t.pa)&&this.is_inArea(t.pb)&&this.is_inArea(t.pc))//包含
{
System.out.println("the previous triangle contains the following triangle");
}
else
{
System.out.println("the previous triangle is interlaced with the following triangle");
}
}
public void contain(Quadrilateral q)
{
ArrayList<Point> list1 = new ArrayList<Point>(Arrays.asList(pa,pb,pc));
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(q.p1,q.p2,q.p3,q.p4));
if(!this.is_inArea(q.p1)&&!this.is_inArea(q.p2)&&!this.is_inArea(q.p3)&&!this.is_inArea(q.p4)
&&!q.is_inArea(pa)&&!q.is_inArea(pb)&&!q.is_inArea(pc))//分离
{
System.out.println("no overlapping area between the previous triangle and the following quadrilateral");
}
else if(Math.abs(Mediator.getArea(list1, list2))<0.00001) //交错
{
System.out.println("the previous triangle is connected to the following quadrilateral");
}
else if(q.is_inArea(pa)&&q.is_inArea(pb)&&q.is_inArea(pc))//被包含
{
System.out.println("the previous triangle is inside the following quadrilateral");
}
else if(this.is_inArea(q.p1)&&this.is_inArea(q.p2)&&this.is_inArea(q.p3)&&this.is_inArea(q.p4))//包含
{
System.out.println("the previous triangle contains the following quadrilateral");
}
else//分离
{
System.out.println("the previous triangle is interlaced with the following quadrilateral");
}
}
public void contain(Pentagon w){
ArrayList<Point> list1 = new ArrayList<Point>(Arrays.asList(pa,pb,pc));
ArrayList<Point> list2 = new ArrayList<Point>(Arrays.asList(w.p1,w.p2,w.p3,w.p4,w.p5));
if(!this.is_inArea(w.p1)&&!this.is_inArea(w.p2)&&!this.is_inArea(w.p3)&&!this.is_inArea(w.p4)&&!this.is_inArea(w.p5)
&&!w.is_inArea(pa)&&!w.is_inArea(pb)&&!w.is_inArea(pc))//分离
{
System.out.println("no overlapping area between the previous triangle and the following pentagon");
}
else if(Math.abs(Mediator.getArea(list1, list2))<0.00001)//连接
{
System.out.println("the previous triangle is connected to the following pentagon");
}
else if(this.is_inArea(w.p1)&&this.is_inArea(w.p2)&&this.is_inArea(w.p3)&&this.is_inArea(w.p4)&&this.is_inArea(w.p5))//包含
{
System.out.println("the previous triangle contains the following pentagon");
}
else if(w.is_inArea(pa)&&w.is_inArea(pb)&&w.is_inArea(pc))//被包含
{
System.out.println("the previous triangle is inside the following pentagon");
}
else//交错
{
System.out.println("the previous triangle is interlaced with the following pentagon");
}
}
public boolean is_inside(Triangle t)
{
if(this.is_inArea(t.pa)&&this.is_inArea(t.pb)&&this.is_inArea(t.pc))
{
return true;
}
return false;
}
public boolean is_inside(Quadrilateral q)
{
if(this.is_inArea(q.p1)&&this.is_inArea(q.p2)&&this.is_inArea(q.p3)&&this.is_inArea(q.p4))
{
return true;
}
return false;
}
public boolean is_inside(Pentagon w)
{
if(this.is_inArea(w.p1)&&this.is_inArea(w.p2)&&this.is_inArea(w.p3)&&this.is_inArea(w.p4)&&this.is_inArea(w.p5))//包含
{
return true;
}
return false;
}
}
期中考试第一二题无问题，第三题不会写，后面会写，改进建议附源码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
double x1,y1,x2,y2;
String color;
Scanner input = new Scanner(System.in);
int choice = 0,index = 0;
GeometryObject container = new GeometryObject();
choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1:
x1 = input.nextDouble();
y1 = input.nextDouble();
container.add(new Point(x1,y1));
break;
case 2:
x1 = input.nextDouble();
y1 = input.nextDouble();
x2 = input.nextDouble();
y2 = input.nextDouble();
color = input.next();
container.add(new Line(new Point(x1,y1),new Point(x2,y2),color));
break;
case 3:
color = input.next();
container.add(new Plane(color));
break;
case 4:
index = input.nextInt();
container.remove(index);
break;
}
choice = input.nextInt();
}
for(Element element:container.getList()) {
element.display();
}
input.close();
}
}
abstract class Element {
public abstract void display();
}
class GeometryObject {
private ArrayList<Element> list = new ArrayList<>();
public GeometryObject() {
}
public void add(Element element) {
list.add(element);
}
public void remove(int index) {
if(index < 1 || index > list.size()) {
return;
}
list.remove(index - 1);
}
public ArrayList<Element> getList(){
return this.list;
}
}
class Line extends Element{
private Point point1,point2;
private String color;
public Line(){
}
public Line(Point p1,Point p2,String color){
this.point1 = p1;
this.point2 = p2;
this.color = color;
}
public Point getPoint1() {
return point1;
}
public void setPoint1(Point point1) {
this.point1 = point1;
}
public Point getPoint2() {
return point2;
}
public void setPoint2(Point point2) {
this.point2 = point2;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getDistance(){
return Math.sqrt(Math.pow(this.point1.getX() - this.point2.getX(), 2) +
Math.pow(this.getPoint1().getY() - this.getPoint2().getY(), 2));
}
@Override
public void display(){
System.out.println("The line's color is:" + this.getColor());
System.out.println("The line's begin point's Coordinate is:");
this.getPoint1().display();
System.out.println("The line's end point's Coordinate is:");
this.getPoint2().display();
System.out.println("The line's length is:" + String.format("%.2f", this.getDistance()));
}
}
class Plane extends Element{
private String color;
public Plane() {
super();
// TODO Auto-generated constructor stub
}
public Plane(String color) {
super();
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public void display() {
// TODO Auto-generated method stub
System.out.println("The Plane's color is:" + this.color);
}
}
class Point extends Element{
private double x,y;
public Point(){
}
public Point(double x,double y){
this.x = x;
this.y = y;
}
public double getX(){
return this.x;
}
public void setX(double x){
this.x = x;
}
public double getY(){
return this.y;
}
public void setY(double y){
this.y = y;
}
@Override
public void display(){
System.out.println("(" + String.format("%.2f", x) + "," + String.format("%.2f",y) + ")");
}
}
第六次作业第二、三题没问题
第一题当时不会写，改进建议附上源码
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Scanner;
public class Main {
public static SimpleDateFormat sdf = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
var uPattern0 = "[u]-0791[0-9]{7,8}\\s[0]";
var tPattern0 = "[t]-0791[0-9]{7,8}\\s" + "0[0-9]{9,11}\\s";
var timePattern = "" +
"((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.(((0?[13578]|1[02])\\.(0?" +
"[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|(((" +
"[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))" +
"\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])\\s" +
"((([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]|[0-9][1-9][0-9]{2}|[1-9][0-9]{3})\\.((([13578]|1[02])\\.(" +
"[1-9]|[12][0-9]|3[01]))|(([469]|11)\\.([1-9]|[12][0-9]|30))|(2\\.([1-9]|[1][0-9]|2[0-8]))))|(((" +
"[0-9]{2})([48]|[2468][048]|[13579][26])|(([48]|[2468][048]|[3579][26])00))\\.2\\.29))" +
"\\s([0-1]?[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])";
var exitPattern = "end";
ArrayList<User> users = new ArrayList<User>();
boolean isT = false;
while(true) {
String string = input.nextLine();
String[] strings = string.split(" ");
if (string.matches(uPattern0) && !isT) {
User user = new User(string);
if (!users.contains(user)) {
users.add(user);
}
} else if (string.matches(tPattern0 + timePattern)) {
String userNumber = strings[0].substring(2);
for (User each:users) {
if (each.getNumber().equals(userNumber)) {
CallRecord callRecord = new CallRecord();
String startDateString = strings[2] + " " + strings[3];
String endDateString = strings[4] + " " + strings[5];
Date startDate;
Date endDate;
try {
startDate = sdf.parse(startDateString);
} catch (ParseException e) {
continue;
}
try {
endDate = sdf.parse(endDateString);
} catch (ParseException e) {
continue;
}
callRecord.setCallingNumber(strings[0].substring(2));
callRecord.setAnswerNumber(strings[2]);
callRecord.setStartTime(startDate);
callRecord.setEndTime(endDate);
callRecord.setCallingAddressAreaCode("0791");
if (strings[1].substring(0, 4).matches("0791")) {
callRecord.setAnswerAddressAreaCode("0791");
each.getUserRecords().addCallToCityRecords(callRecord);
} else if (strings[1].substring(0, 4).matches("07(9[0-9]{1}|01)")) {
callRecord.setAnswerAddressAreaCode(strings[1].substring(0, 4));
each.getUserRecords().addCallToProvinceRecords(callRecord);
} else {
callRecord.setAnswerAddressAreaCode(strings[1].substring(0, 4));
each.getUserRecords().addCallToLandRecords(callRecord);
}
isT = true;
}
}
} else if (string.matches(exitPattern)) {
break;
}
}
Collections.sort(users, new Comparator<User>() {
public int compare(User user1, User user2) {
return user1.getNumber().compareTo(user2.getNumber());
}
});
for (User each:users) {
System.out.println(each.getNumber() + " " + String.format("%.1f", each.calCost()) + " " + String.format("%.1f", each.calBalance()));
}
input.close();
}
}
abstract class CallChargeRule extends ChargeRule{
public CallChargeRule() {
// TODO Auto-generated constructor stub
}
public double calCost(ArrayList<CallRecord> callRecords) {
return 0;
}
}
class CallRecord extends CommunicationRecord{
private Date startTime;
private Date endTime;
private String callingAddressAreaCode;
private String answerAddressAreaCode;
public CallRecord() {
// TODO Auto-generated constructor stub
}
public Date getStartTime() {
return startTime;
}
public void setStartTime(Date startTime) {
this.startTime = startTime;
}
public Date getEndTime() {
return endTime;
}
public void setEndTime(Date endTime) {
this.endTime = endTime;
}
public String getCallingAddressAreaCode() {
return callingAddressAreaCode;
}
public void setCallingAddressAreaCode(String callingAddressAreaCode) {
this.callingAddressAreaCode = callingAddressAreaCode;
}
public String getAnswerAddressAreaCode() {
return answerAddressAreaCode;
}
public void setAnswerAddressAreaCode(String answerAddressAreaCode) {
this.answerAddressAreaCode = answerAddressAreaCode;
}
}
abstract class ChargeMode {
private ArrayList<ChargeRule> chargeRules = new ArrayList<ChargeRule>();
public ChargeMode() {
}
public void addChargeRule(ChargeRule chargeRule) {
chargeRules.add(chargeRule);
}
public ArrayList<ChargeRule> getChargeRules() {
return chargeRules;
}
public void setChargeRules(ArrayList<ChargeRule> chargeRules) {
this.chargeRules = chargeRules;
}
public double calCost(UserRecords userRecords) {
return 0;
}
public double getMonthlyRent() {
return 0;
}
}
abstract class ChargeRule {
public ChargeRule() {
// TODO Auto-generated constructor stub
}
public double calCost(ArrayList<CallRecord> callRecords) {
return 0;
}
}
abstract class CommunicationRecord {
private String callingNumber;
private String answerNumber;
public CommunicationRecord() {
// TODO Auto-generated constructor stub
}
public String getCallingNumber() {
return callingNumber;
}
public void setCallingNumber(String callingNumber) {
this.callingNumber = callingNumber;
}
public String getAnswerNumber() {
return answerNumber;
}
public void setAnswerNumber(String answerNumber) {
this.answerNumber = answerNumber;
}
}
class LandlinePhoneCharging extends ChargeMode{
private double monthlyRent = 20;
public LandlinePhoneCharging() {
super.addChargeRule(new LandPhoneInCityRule());
super.addChargeRule(new LandPhoneInProvinceRule());
super.addChargeRule(new LandPhoneInLandRule());
}
@Override
public double calCost(UserRecords userRecords) {
double cost = 0;
cost += super.getChargeRules().get(0).calCost(userRecords.getCallToCityRecords());
cost += super.getChargeRules().get(1).calCost(userRecords.getCallToProvinceRecords());
cost += super.getChargeRules().get(2).calCost(userRecords.getCallToLandRecords());
return cost;
}
@Override
public double getMonthlyRent() {
return monthlyRent;
}
}
class LandPhoneInCityRule extends CallChargeRule{
public LandPhoneInCityRule() {
// TODO Auto-generated constructor stub
}
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double cost = 0;
for (CallRecord each:callRecords) {
long startTime = each.getStartTime().getTime();
long endTime = each.getEndTime().getTime();
int minute = (int)(endTime - startTime) / 60000;
int Second = (int)(endTime - startTime) % 60000 / 1000;
if (Second > 0) {
minute ++;
}
cost += minute * 0.1;
}
return cost;
}
}
class LandPhoneInLandRule extends CallChargeRule{
public LandPhoneInLandRule() {
// TODO Auto-generated constructor stub
}
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double cost = 0;
for (CallRecord each:callRecords) {
long startTime = each.getStartTime().getTime();
long endTime = each.getEndTime().getTime();
int minute = (int)(endTime - startTime) / 60000;
int Second = (int)(endTime - startTime) % 60000 / 1000;
if (Second > 0) {
minute ++;
}
cost += minute * 0.6;
}
return cost;
}
}
class LandPhoneInProvinceRule extends CallChargeRule{
public LandPhoneInProvinceRule() {
// TODO Auto-generated constructor stub
}
@Override
public double calCost(ArrayList<CallRecord> callRecords) {
double cost = 0;
for (CallRecord each:callRecords) {
long startTime = each.getStartTime().getTime();
long endTime = each.getEndTime().getTime();
int minute = (int)(endTime - startTime) / 60000;
int Second = (int)(endTime - startTime) % 60000 / 1000;
if (Second > 0) {
minute ++;
}
cost += minute * 0.3;
}
return cost;
}
}
private UserRecords userRecords = new UserRecords();
private double balance = 100;
private ChargeMode chargeMode;
private String number = new String();
public User() {
// TODO Auto-generated constructor stub
}
public User(String string) {
String[] strings = string.split("\\s");
number = strings[0].substring(2);
chargeMode = new LandlinePhoneCharging();
}
public double calBalance() {
return balance - calCost() - chargeMode.getMonthlyRent();
}
public double calCost() {
return chargeMode.calCost(userRecords);
}
public UserRecords getUserRecords() {
return userRecords;
}
public void setUserRecords(UserRecords userRecords) {
this.userRecords = userRecords;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public ChargeMode getChargeMode() {
return chargeMode;
}
public void setChargeMode(ChargeMode chargeMode) {
this.chargeMode = chargeMode;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
@Override
public boolean equals(Object obj) {
User temp = (User) obj;
return temp.getNumber().equals(number);
}
}
private ArrayList<CallRecord> callToCityRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callToProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callToLandRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callOutOfCityRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> callOutOfProvinceRecords = new ArrayList<CallRecord>();
private ArrayList<CallRecord> answerOutOfProvinceRecords = new ArrayList<CallRecord>();
public UserRecords() {
// TODO Auto-generated constructor stub
}
public void addCallToCityRecords (CallRecord callRecord) {
callToCityRecords.add(callRecord);
}
public void addCallToProvinceRecords (CallRecord callRecord) {
callToProvinceRecords.add(callRecord);
}
public void addCallToLandRecords (CallRecord callRecord) {
callToLandRecords.add(callRecord);
}
public void addCallOutOfCityRecords (CallRecord answerRecord) {
callOutOfCityRecords.add(answerRecord);
}
public void addCallOutOfProvinceRecords (CallRecord answerRecord) {
callOutOfProvinceRecords.add(answerRecord);
}
public void addAnswerOutOfProvinceRecords (CallRecord answerRecord) {
answerOutOfProvinceRecords.add(answerRecord);
}
public ArrayList<CallRecord> getCallToCityRecords() {
return callToCityRecords;
}
public ArrayList<CallRecord> getCallToProvinceRecords() {
return callToProvinceRecords;
}
public ArrayList<CallRecord> getCallToLandRecords() {
return callToLandRecords;
}
public ArrayList<CallRecord> getCallOutOfCityRecords() {
return callOutOfCityRecords;
}
public ArrayList<CallRecord> getCallOutOfProvinceRecords() {
return callOutOfProvinceRecords;
}
public ArrayList<CallRecord> getAnswerOutOfProvinceRecords() {
return answerOutOfProvinceRecords;
}
}
第七次作业第一、二、三题都没问题
第八次作业第一、二、三题都没问题
总结：1.Java的运行(基础必备) 这条可能出看很简单，java程序的运行谁不会呢?不过很多时候， 我们只是单纯通过IDE去执行java程序，底层IDE又是如何执行java程序呢?很多人并不了解。
2.这个知识点是最最基本的java开发者需要掌握的，初学java，第一个肯定是教你如何在命令行中执行java程序，但是很多人一旦把java学完 了，IDE用上了，就把这个都忘了。为什么强调要知道这个呢，知道了java最纯粹的启动方式之后，你才能在启动出问题的时候，去分析当时启动的目录多少，执行命名如何，参数如何，是否有缺失等。 这样有利于你真正开发中去解决那些奇奇怪怪的可能和环境相关的问题。
在这里需要掌握的知识有： javac 编译java文件为 class 文件java 命令的使用， 带package的java类如何在命令行中启动java程序涉及到的各个路径(classpath， java。library。path， java运行的主目录等)
3.数据类型 这条没有什么好多说的，无非就是Java中的基本类型和对象类型的掌握。可以再了解一些JDK如何自动转换方面的知识，包括装箱拆箱等，还要注意避免装箱之后的类型相等的判断 主要知识点： 基本类型： int， long， float， double， boolean ······ 对应的对象类型： Integer 等类型到基本类型的转换， 装箱和拆箱Object类型： equals， hashcodeString 类型的特点
4.对象和实例，对象的创建 ，在这方面，开发者需要了解class和instance的概念以及之间的差别， 这是java面向对象特性的一个基础。
主要知识点有：Class和 Instance 的概念； Instance 创建的过程：1. 无继承：分配内存空间， 初始化变量， 调用构造函数；2.有继承：处理静态动作， 分配内存空间， 变量定义为初始值 ， 从基类->子类， 处理定义处的初始化， 执行构造方法； 需要注意的点：静态属性等从基类->子类进行初始化；默认无参构造方法相关的特性。
5.访问控制 这也是java封装特性的一个基础需要掌握的有：public protected default private 对于class， method， field 的修饰作用
6.流程控制 Java 流程控制的基础，虽然有些语法不一定很常用，但是都需要了解，并且在合适的地方使用它们。需要掌握的有： if， switch， loop， for， while 等流程控制的语法
7.面向对象编程的概念 这是一个java的核心概念，对于任何java开发者都需要熟练掌握。Java中很多特性或者说知识点都是和java面向对象编程概念相关的。在我的理解， 一个好的开发者不仅仅需要了解这些特性(知识点)本身，也更需要知道这些对象在java的面向对象编程概念中是如何体现出来的，这样更有利于开发者掌握 java这门开发语言，以及其他面向对象编程的语言。
主要的知识点包括有：面向对象三大特性：封装，继承，多态; 各自的定义概念，有哪些特性体现出 来，各自的使用场景静态多分派，动态单分派的概念重载的概念和使用继承：接口多实现，基类单继承抽象，抽象类，接口多态：方法覆盖的概念和使用接口回调
8.Static 静态属性在java日常开发中也是经常使用，需要了解和 static 关键字相关的用法，还有和其他关键字的配合使用， 如是否可以和 abstract， final 等关键字联合使用。 主要需要掌握的有：静态属性的定义，使用，以及类加载时如何初始化静态方法的定义和使用静态类的定义和使用静态代码块的定义和初始化时机。
9.学会了类与类类与对象之间的关系，知道怎么写点线形类题目。
10.对教师和课上尽量不要很快的讲新东西，需要有一个细嚼慢咽的过程，希望教师多多讲一下作业该怎么写以及一些基础知识的温习，作业方面尽量出一些难易结合的题目，而不是都是难题，实验课上希望老师在实验方面能够指导一下学生往哪个方向思考。
【推荐】国内首个AI IDE，深度理解中文开发场景，立即下载体验Trae
【推荐】编程新体验，更懂你的AI，立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包，你的智能百科全书，全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell：AI 加持，快人一步
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 提示词工程——AI应用必不可少的技术
· 地球OL攻略 —— 某应届生求职总结
· 字符编码：从基础到乱码解决
· SpringCloud带你走进微服务的世界