第二次博客作业

前言

本月主要主要学习了继承与多态，正则表达式的运用，容器，流等内容，理解起来可能问题不大，但在实际操作的过程中总会出现一些大大小小的问题，因此这个月PTA作业花费的时间明显比上个月多了许多，很多时候一天都做不出来一道题，对我们逻辑的严谨性要求更严了，也就是说我们不能像以前那样拿到题目就做，而是因该先仔细读题，在内心里构建起最初的框架，用纸笔写出来，最后再用程序去实现，我认为花部分时间去布局，可以有效的提升编程的效率和代码的质量。

 

本月所学

1、继承于多态

我们在写程序的时候经常会遇到，多个类的模式大体相同，这样会显得代码非常冗余。

例如，PTA题目集06的第二题，最开始我的想法是分别创建4个类L1_2,L2_3,L3_4,L4_1来储存四边形每条线段的长度和对应点的坐标，之后提交的时候应为代码长度超限，所以创建了一个父类Sample,将类L1_2,L2_3,L3_4,L4_1中重复的数据储存到父类中，但很可惜的是，在之后升级代码的时候，我取消了这个设计，因此没有对应代码来展示父类对于代码的精简的重要作用。

其实多态的概念到现在我还不是特别清楚，套用定义来说就是 是指同一行为，具有多个不同表现形式，比方说在父类中定义一个方法print，在A类中重写该方法，在B类中不做任何操作，然后在Main中分别创建A，B的对象a，b。调用方法a.print和b.print，会发现a用的父类定义的方法，b则用的是B类重写后的方法。一个方法干了多件不同的事情就是多态。

2、正则表达式

正则表达式的学习可以在最大程度上优化我们的代码长度。

例如，PTA题目集04的三道题，我当时做这套题目集的时候可以用坐牢来形容，测试点五花八门的格式错误，由于缺乏写代码前的设计环节，所以总是漏掉不同种类的格式错误，在判断格式的环节，无数个if排放在一起，使得在后期检查的时候的工作量非常之大，当时有很多格式错误的要求可谓是困扰我许久。

比如说：00,0.00  （这种错误其实挺有争议的，严格意义上来说00可以看作是0，因此在后面的题目里，取消了这种情况）

　　　　小数点数量位置错误以及小数点的存在性 （需要很多if来判断，非常难受）

　　　　...

在做题目集04的7-1时，我最开始代码写了快400行，逻辑相当混乱，于是我又推到重写，将代码压缩到了150行，起初我和室友对比了一下，发现自己代码挺简练的，有点沾沾自喜，觉得自己写了一回高质量代码。结果发现隔壁有个人，用50行解决了习题7-1。我当时大为震惊，通过询问才得知了正则表达式的存在，由于没太看懂，加上后面两题错误格式测试点和第一题差不多一样，就没有用正则了。

后面学习了正则之后，才真正意义上了解到了正则表达式的强大之处，这里举几个例子来说明一下

1.题目集06习题7-2

num=arr.split("\\s");   //切割字符串
for(int i=0;i<num.length;i++) {
        if(!checkNum(num[i])) {
            System.out.println("Wrong Format");
        passport++;
        break;
        }        
}

public boolean checkNum(String num) {  //检查格式是否错误
    String reagex="((-?([1-9]\\d*[.]\\d*|0\\[.]\\d*[1-9]\\d*))|-?[1-9]\\d*|0),((-?([1-9]\\d*[.]\\d*|0\\[.]\\d*[1-9]\\d*))|-?[1-9]\\d*|0)";
    boolean bool =num.matches(reagex);
    if(bool) {
        return true;
    }
    else {
        return false;
    }
}    

这是我迭代升级后的代码，num是一个字符串数组，先通过空格去切割坐标并储存带num中，再判断格式是否错误。

public String cutArr() {  //切割坐标
    int blankCount=0;
    for(int i=0;i<arr.length();i++) {
        if(arr.charAt(i)==' ') {
            cutArr=arr.substring(0,i);
            arr=arr.substring(i+1,arr.length());
            blankCount++;
            break;
        }
    }
    if(blankCount==0) {
        cutArr=arr.substring(0,arr.length());
    }
    return cutArr;
}

public boolean checkNum(String num) {
    int countOne=0;
    int count=0;
    int j=0;
    //坐标为空
    if(num=="") {
        return false;
    }
    //冒号错误
    if(mark.charAt(0)!=':') {
        return false;
    }
    //判断逗号数量是否错误
    for(int i=0;i<num.length();i++) {
        if(num.charAt(i)==',') {
            countOne++;
        }
    }
    if(countOne!=1) {
            return false;
    }
    //判断小数点数量是否错误
        while(num.charAt(j)!=',') {
        if(num.charAt(j)=='.') {
            count++;
        }
        j++;
    }
    if(count>1) {
        return false;
    }
    count=0;
    while(j<num.length()) {
        if(num.charAt(j)=='.') {
            count++;
        }
        j++;
    }
        if(count>1) {
            return false;
        }
        for(int i=0;i<num.length();i++) {
            
            //非法字符
            if(num.charAt(i)!=',' && num.charAt(i)!='+' && num.charAt(i)!='-' && num.charAt(i)!='.' && (num.charAt(i)<48 || num.charAt(i)>57)) {
                return false;
            }
            //x:00,01
            if((i==0) && (num.charAt(i)=='0' && (num.charAt(i+1)!='.' && num.charAt(i+1)!=','))) {
                return false;
            }
            //y:00,01
            if((num.charAt(i)==',' && i!=num.length()-1 && num.charAt(i+1)=='0' && i+2<num.length()) && (num.charAt(i+2)!='.'))  {
                return false;
            }
            //+,-后面必须接数字
            if((i==0) && ((num.charAt(i)!='+' && num.charAt(i)!='-') && (num.charAt(i)<48 || num.charAt(i)>57))) {
                return false;
            }
            //不得有多个+,-
            if((num.charAt(i)=='+' || num.charAt(i)=='-') && (i!=0 && num.charAt(i-1)!=',')) {
                return false;
            }
            //小数点后必须接数字
            if((num.charAt(i)=='.') && (i==num.length()-1 || (num.charAt(i+1)<48 || num.charAt(i+1)>57))) {
                return false;
            }
            //逗号前后输入是否有误
            if((num.charAt(i)==',') && ((i==num.length()-1 || (num.charAt(i-1)<48 || num.charAt(i-1)>57)) || ((num.charAt(i+1)!='+' && num.charAt(i+1)!= '-') && (num.charAt(i+1)<48 || num.charAt(i+1)>57)))) {
                return false;
            }
            //最后一个字符不能是逗号
            if(num.charAt(num.length()-1)==',') {
                return false;
            }
        }
        return true;
    }    

这是我改进前的代码，由于长度问题我就将代码折叠了，这两部分代码的功能完全是一摸一样的，但代码的质量可谓是天差地别。

其实正则表达式能做到的不仅仅只是优化一些判断的过程，题目集06的习题7-2第一版完工时代码长度为950（不包括选项4），已将逼近了内存限制。加入正则判断后代码长度为490（写完了所有的选项），当然还是可以继续精简的，比如我的室友在写1，2，3，5四个选项的时候代码只有200行。我相信以上足以说明正则表达式的优越性。

目前我在使用正则的时候大多是套用模板，然后加以修改，并没有完全弄明白正则的语法，尚未达到随机应变的能力层次，所以之后仍要加强对正则的运用和学习。

3、容器

1.LinkedList   

2.ArrayList

3.TreeSet

4.HashSet

5.HasLinkedSet

容器可以分为两个大类，List和Set。均用于储存一个种类的数据，可以看作是另一个形式的链表，可以做到，储存，删除，修改查找数据，并且拥有大量的方法去完成这些操作

下面简单介绍一些方法：

public void add(Object element)  //增添元素

public void add(int index,Object element)  //在指定位置增添元素

public boolean remove(Object o)  //删除指定对象

public Object remove(int index)  //删除指定位置的元素

public Object set(int index,Object element)  //修改指定位置元素的值

public Object get(int index)  //获取指定位置元素

public int indexOf(Object o)  //获取指定元素的位置

public boolean contains(Object o)  //判断指定元素是否存在

public int size()  //获取容器中元素个数

public Iterator<E> iterator()  //获取迭代器

public void clear()  //清空元素

ArrayList适合快速查找元素，LinkedList适合频繁地对列表进行增加或删除元素操作，因此LinkedList类可用于实现堆栈和队列，下面是一些LinkedList独特的方法：

public void add(Object element)  //增添元素

public boolean remove(object element)  //删除元素

public boolean contains(Object o)  //判断元素是否存在

public int size()  //获取容器中元素个数

public boolean isEmpty()  //判断集合是否为空

public Iterator<E> iterator()  //获取迭代器

public void clear()  //清空元素 

在软工期中考试7-3D点线面问题重构（容器）中，需要创建一个容器类GeometryObject，用于储存Element类型的数据，我对容器的概念相当的模糊，所以在做题的时候我感觉其实就是在用ArrayList来解决问题。

 

题目分析

PTA题目集4 7-1 点线形系列1-计算两点之间的距离

从现在的角度来看，这道题的难度不大，有了正则表达式可以轻松解决问题，即便不用正则，只要逻辑清晰，也能高效完成本题。

类图：

代码：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        String numOne;
        String numTwo;
        String numThree;
        
        double x1;
        double y1;
        double x2;
        double y2;
        double distance;
        
        int k=0;
        Scanner in = new Scanner(System.in);
        String numArr = in.nextLine();
        checkNum num = new checkNum(numArr);
        k=num.ifTwo();
        if(k==0) {
            System.out.println("Wrong Format");
        }
        else if(k==1) {
            numOne=num.cutArr();
            numTwo=num.cutArr();
            checkNum arrOne = new checkNum(numOne);
            checkNum arrTwo = new checkNum(numTwo);
            if(!arrOne.checkArr()) {
                System.out.println("Wrong Format");
            }
            else if(!arrTwo.checkArr()) {
                System.out.println("Wrong Format");
            }
            else {
                x1=arrOne.cutX(numOne);
                y1=arrOne.cutY(numOne);
                x2=arrTwo.cutX(numTwo);
                y2=arrTwo.cutY(numTwo);
                distance=Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
                System.out.println(distance);
            }
        }
        else if(k>1) {
            numOne=num.cutArr();
            numTwo=num.cutArr();
            numThree=num.cutArr();
            checkNum arrOne = new checkNum(numOne);
            checkNum arrTwo = new checkNum(numTwo);
            checkNum arrThree =new checkNum(numThree);
            if(!arrOne.checkArr()) {
                System.out.println("Wrong Format");
            }
            else if(!arrTwo.checkArr()) {
                System.out.println("Wrong Format");
            }
            else if(!arrThree.checkArr()) {
                System.out.println("Wrong format");
            }
            else {
                System.out.println("wrong number of points");
            }
        }
    }
}

class checkNum {
    
    String num;
    String cutNum;
    String loctOne;
    String loctTwo;
    String loctThree;
    int allBlank=0;
    
    public checkNum(String numArr) {
        num=numArr.substring(0,numArr.length());
    }
    
    //判断是否有两个坐标
    public int ifTwo() {
        for(int i=0;i<num.length();i++) {
            if(num.charAt(i)==' ') {
            allBlank++;
            }
        }
        return allBlank;
    }
    
    //切割字符串
    public String cutArr() {
        int blankCount=0;
        for(int i=0;i<num.length();i++) {
            if(num.charAt(i)==' ') {
                cutNum=num.substring(0,i);
                num=num.substring(i+1,num.length());
                blankCount++;
                break;
            }
        }
        if(blankCount==0) {
            cutNum=num.substring(0,num.length());
        }
        return cutNum;
    }
    
    //检查坐标格式是否正确
    public  boolean checkArr() {
        for(int i=0;i<num.length();i++) {
            if((i==0) && (num.charAt(i+1)=='0' && num.charAt(i+2)!='.')) {
                return false;
            }
            if((i==0) && ((num.charAt(i)!='+' && num.charAt(i)!='-') && (num.charAt(i)<48 || num.charAt(i)>57))) {
                return false;
            }
            if((num.charAt(i)=='.') && (i==num.length()-1 || (num.charAt(i+1)<48 || num.charAt(i+1)>57))) {
                return false;
            }
            if((num.charAt(i)==',') && ((i==num.length()-1 || (num.charAt(i-1)<48 || num.charAt(i-1)>57)) || ((num.charAt(i+1)!='+' && num.charAt(i+1)!= '-') && (num.charAt(i+1)<48 || num.charAt(i+1)>57)))) {
                return false;
            }
            if((num.charAt(i)=='+' || num.charAt(i)=='-') && ((num.charAt(i+1)<48 || num.charAt(i+1)>57) || (i==num.length()-1))) {
                return false;
            }
            if(num.charAt(i)==' ') {
                return false;
            }
        }
        return true;
    }
    
    //切割得x的值
    public double cutX(String arr) {
        String X;
        double x=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==',') {
                X=arr.substring(0,i);
                x=Double.parseDouble(X);
                break;
            }
        }
        return x;
    }
    
    //切割得y的值
    public double cutY(String arr) {
        String Y;
        double y=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==',') {
                Y=arr.substring(i+1,arr.length());
                y=Double.parseDouble(Y);
                break;
            }
        }
        return y;
    }
}

 

PTA题目集4 7-2点线形系列2-线的计算

本体是上一题的迭代版本，难度不大，重点在于，等于关系，需要用精确值。

例：x1=x2，判断条件为：Math.abs(x1-x2)<0.001。

类图：

代码：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        cauTangle what = new cauTangle();
        what.option();
    }
}

class cauTangle {
    
    Scanner in = new Scanner(System.in);
    
    String arr;  //输入的字符串
    String cutArr;  //坐标
    String head;  //字符串前缀
    String mark;  //英文冒号
    String choice;  //选项
    
    int wrong=0;
    int Choice=0;  //选项
    int allBlank=0;  //空格的数量
    
    double l1=0;
    double l2=0;
    double l3=0;
    
    double L1=0;
    double L2=0;
    double L3=0;
    
    double s1=0;
    double s2=0;
    double s3=0;
    double S=0;
    
    double x1=0;
    double y1=0;
    double x2=0;
    double y2=0;
    double x3=0;
    double y3=0;
    double x4=0;
    double y4=0;
    double x5=0;
    double y5=0;
    
    String numOne;
    String numTwo;
    String numThree;
    String numFour;
    String numFive;
    String numSix;
    
    public void option() {
        inPut();
        if(arr.length()==1) {
            System.out.println("Wrong Format");
            wrong++;
        }
        else {
            cutHead();
            cutOption();
            if(arr.charAt(0)==' ') {
                System.out.println("Wrong Format");
                wrong++;
            }
        }
        if((wrong==0) && (choice.charAt(0)=='1' || choice.charAt(0)=='2' || choice.charAt(0)=='3' || choice.charAt(0)=='4' || choice.charAt(0)=='5')) {
            Choice=Integer.parseInt(choice);
        }
        else {
            System.out.println("Wrong Format");
            wrong++;
        }
        if(wrong==0) {
            switch(Choice) {
                case 1:
                    isqWeather();
                    break;
                case 2:
                    algorTra();
                    break;
                case 3:
                    whatAngle();
                    break;
                case 4:
                    centreNum();
                    break;
                case 5:
                    outWeather();
            }
        }
    }
    
    //输入字符串
    public void inPut() {
        arr=in.nextLine();
    }
    
    //切去头部
    public void cutHead() {
        head=arr.substring(0,2);
        arr=arr.substring(2,arr.length());
    }
    
    //提取选项与符号
    public void cutOption() {
        choice=head.substring(0,1);
        mark=head.substring(1,2);
    }
    
    //切割坐标
    public String cutArr() {
        int blankCount=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==' ') {
                cutArr=arr.substring(0,i);
                arr=arr.substring(i+1,arr.length());
                blankCount++;
                break;
            }
        }
        if(blankCount==0) {
            cutArr=arr.substring(0,arr.length());
        }
        return cutArr;
    }
    
    //计算空格的个数
    public int numBlank() {
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==' ' && i!=arr.length()-1) {
            allBlank++;
            }
        }
        return allBlank;
    }
    
    //判断输入数据是多于所需数据
    public boolean numData(int n) {
        switch(Choice) {
            case 1:
                if(allBlank!=2) {
                    return false;
                }
                else {
                    return true;
                }
            case 2:
                if(allBlank!=2) {
                    return false;
                }
                else {
                    return true;
                }
            case 3:
                if(allBlank!=2) {
                    return false;
                }
                else {
                    return true;
                }
            case 4:
                if(allBlank!=4) {
                    return false;
                }
                else {
                    return true;
                }
            case 5:
                if(allBlank!=3) {
                    return false;
                }
                else {
                    return true;
                }        
        }
        return false;
    }
    
    //切割得x的值
    public double cutX(String arr) {
        String X;
        double x=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==',') {
                X=arr.substring(0,i);
                x=Double.parseDouble(X);
                break;
            }
        }
        return x;
    }
        
    //切割得y的值
    public double cutY(String arr) {
        String Y;
        double y=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==',') {
                Y=arr.substring(i+1,arr.length());
                y=Double.parseDouble(Y);
                break;
            }
        }
        return y;
    }
    
    //检查格式是否错误
    public boolean checkNum(String num) {
        int countOne=0;
        int count=0;
        int j=0;
        //坐标为空
        if(num=="") {
            return false;
        }
        //冒号错误
        if(mark.charAt(0)!=':') {
            return false;
        }
        //判断逗号数量是否错误
        for(int i=0;i<num.length();i++) {
            if(num.charAt(i)==',') {
                countOne++;
            }
        }
        if(countOne!=1) {
            return false;
        }
        //判断小数点数量是否错误
        while(num.charAt(j)!=',') {
            if(num.charAt(j)=='.') {
                count++;
            }
            j++;
        }
        if(count>1) {
            return false;
        }
        count=0;
        while(j<num.length()) {
            if(num.charAt(j)=='.') {
                count++;
            }
            j++;
        }
        if(count>1) {
            return false;
        }
        for(int i=0;i<num.length();i++) {
            
            //非法字符
            if(num.charAt(i)!=',' && num.charAt(i)!='+' && num.charAt(i)!='-' && num.charAt(i)!='.' && (num.charAt(i)<48 || num.charAt(i)>57)) {
                return false;
            }
            //x:00,01
            if((i==0) && (num.charAt(i)=='0' && (num.charAt(i+1)!='.' && num.charAt(i+1)!=','))) {
                return false;
            }
            //y:00,01
            if((num.charAt(i)==',' && i!=num.length()-1 && num.charAt(i+1)=='0' && i+2<num.length()) && (num.charAt(i+2)!='.'))  {
                return false;
            }
            //+,-后面必须接数字
            if((i==0) && ((num.charAt(i)!='+' && num.charAt(i)!='-') && (num.charAt(i)<48 || num.charAt(i)>57))) {
                return false;
            }
            //不得有多个+,-
            if((num.charAt(i)=='+' || num.charAt(i)=='-') && (i!=0 && num.charAt(i-1)!=',')) {
                return false;
            }
            //小数点后必须接数字
            if((num.charAt(i)=='.') && (i==num.length()-1 || (num.charAt(i+1)<48 || num.charAt(i+1)>57))) {
                return false;
            }
            //逗号前后输入是否有误
            if((num.charAt(i)==',') && ((i==num.length()-1 || (num.charAt(i-1)<48 || num.charAt(i-1)>57)) || ((num.charAt(i+1)!='+' && num.charAt(i+1)!= '-') && (num.charAt(i+1)<48 || num.charAt(i+1)>57)))) {
                return false;
            }
            //最后一个字符不能是逗号
            if(num.charAt(num.length()-1)==',') {
                return false;
            }
        }
        return true;
    }
    
    public boolean traWeather() {
        if(l1+l2>l3 && l2+l3>l1 && l1+l3>l2) {
            return true;
        }
        else {
            return false;
        }
    }
    
    public boolean parWeather(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {
        double k1=0;
        double k2=0;
//        System.out.println("1");
        if(x3!=x4 && x3!=x4) {
            k1=(y3-y4)/(x3-x4);
            k2=(y1-y2)/(x1-x2);
            if(k1==k2) {
                return true;
            }
        }
        if(x3!=x4 && x3==x4) {
            return false;
        }
        if(x3==x4 && x3!=x4) {
            return false;
        }
        if(x3==x4 && x1==x2) {
            return true;
        }
        return false;
    }
    
    public boolean sameWeather(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {
        double k1=0;
        double k2=0;
        double k3=0;
        if(x3==x4)
            if(x1==x3) {
                return true;
            }
            else {
                return false;
        }
        else {
            k1=(y3-y4)/(x3-x4);
            k2=(y2-y3)/(x2-x3);
            k3=(y2-y4)/(x2-x4);
            if(k1==k2 || k3==k1) {
                return true;
            }
            else {
                return false;
            }
        }
    }
    
    //case 1
    public void isqWeather() {        
        if(numData(numBlank())) {
            numOne=cutArr();
            numTwo=cutArr();
            numThree=cutArr();
            if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree)) {
                x1=cutX(numOne);
                y1=cutY(numOne);
                x2=cutX(numTwo);
                y2=cutY(numTwo);
                x3=cutX(numThree);
                y3=cutY(numThree);
                l1=Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
                l2=Math.sqrt(Math.pow(x2-x3,2)+Math.pow(y2-y3,2));
                l3=Math.sqrt(Math.pow(x1-x3,2)+Math.pow(y1-y3,2));
                if(traWeather()) {
                    if((Math.abs(l1-l2)<0.000001) || (Math.abs(l1-l3)<0.000001) || (Math.abs(l2-l3)<0.000001)) {
                        System.out.print("true"+" ");
                    }
                    else {
                        System.out.print("false"+" ");
                    }
                    if(l1==l2 && l2==l3) {
                        System.out.print("true");
                    }
                    else {
                        System.out.print("false");
                    }
                }
                else {
                    System.out.println("data error");
                }
            }
            else {
                System.out.println("Wrong Format");
            }
        }
        else {
            if(allBlank<2) {
                numOne=cutArr();
                numTwo=cutArr();
                if(checkNum(numOne) && checkNum(numTwo)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
            else if(allBlank>2) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
        }
    }
    
    //case 2
    public void algorTra() {        
        double x=0;
        double y=0;
        double area=0;
        double c=0;
        
        if(numData(numBlank())) {
            numOne=cutArr();
            numTwo=cutArr();
            numThree=cutArr();
            if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree)) {
                x1=cutX(numOne);
                y1=cutY(numOne);
                x2=cutX(numTwo);
                y2=cutY(numTwo);
                x3=cutX(numThree);
                y3=cutY(numThree);
                l1=Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
                l2=Math.sqrt(Math.pow(x2-x3,2)+Math.pow(y2-y3,2));
                l3=Math.sqrt(Math.pow(x1-x3,2)+Math.pow(y1-y3,2));
                if(traWeather()) {
                    x=(x1+x2+x3)/3;
                    y=(y1+y2+y3)/3;
                    area=0.5*(x1*y2-x1*y3+x2*y3-x2*y1+x3*y1-x2*y2);  
                    c=l1+l2+l3;
                    System.out.println((double)Math.round(c*1000000)/1000000+" "+(double)Math.round(area*1000000)/1000000+" "+(double)Math.round(x*1000000)/1000000+","+(double)Math.round(y*1000000)/1000000);
                }
                else {
                    System.out.println("data error");
                }
            }
            else {
                System.out.println("Wrong Format");
            }
        }
        else {
            if(allBlank<2) {
                numOne=cutArr();
                numTwo=cutArr();
                if(checkNum(numOne) && checkNum(numTwo)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
            else if(allBlank>2) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
        }
    }
    
    //case 3
    public void whatAngle() {
        
        if(numData(numBlank())) {
            numOne=cutArr();
            numTwo=cutArr();
            numThree=cutArr();
            if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree)) {
                x1=cutX(numOne);
                y1=cutY(numOne);
                x2=cutX(numTwo);
                y2=cutY(numTwo);
                x3=cutX(numThree);
                y3=cutY(numThree);
                l1=Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
                l2=Math.sqrt(Math.pow(x2-x3,2)+Math.pow(y2-y3,2));
                l3=Math.sqrt(Math.pow(x1-x3,2)+Math.pow(y1-y3,2));
                L1=l1*l1;
                L2=l2*l2;
                L3=l3*l3;
                if(traWeather()) {
                    //钝角
                    if((L1-(L2+L3))>0.000001 || (L2-L1-L3)>0.000001 || (L3-L1-L2)>0.000001) {
                        System.out.print("true"+" ");
                    }
                    else {
                        System.out.print("false"+" ");
                    }
                    //直角
                    if(Math.abs(L1-(L2+L3))<0.00001 || Math.abs(L2-(L1+L3))<0.00001 || Math.abs(L3-(L1+L2))<0.00001) {
                        System.out.print("true"+" ");
                    }
                    else {
                        System.out.print("false"+" ");
                    }
                    //锐角
                    if(L1-L2-L3<-0.000001 && L2-L1-L3<-0.000001 && L3-L1-L2<-0.000001) {
                        System.out.print("true");
                    }
                    else {
                        System.out.print("false");
                    }
                }
                else {
                    System.out.println("data error");
                }
            }
        }
        else {
            if(allBlank<2) {
                numOne=cutArr();
                numTwo=cutArr();
                if(checkNum(numOne) && checkNum(numTwo)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
            else if(allBlank>2) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
        }
    }
    
    //case 4
    public void centreNum() {        
        //第一条直线与每条边的交点
        double pX1=0;
        double pY1=0;
        double pX2=0;
        double pY2=0;
        double pX3=0;
        double pY3=0;
        
        double S=0;
        double s1=0;
        double s2=0;
        double temp=0;
        
        int countOne=0;
        int countTwo=0;
        int countThree=0;
        int wrongPiont1=0;
        int wrongPiont2=0;
        int wrongPiont3=0;
        int allCount=0;
        int wrongPiont=0;
        int num=0;
        
        
        if(numData(numBlank())) {
            numOne=cutArr();
            numTwo=cutArr();
            numThree=cutArr();
            numFour=cutArr();
            numFive=cutArr();
            if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour) && checkNum(numFive)) {
                x1=cutX(numOne);
                y1=cutY(numOne);
                x2=cutX(numTwo);
                y2=cutY(numTwo);
                x3=cutX(numThree);
                y3=cutY(numThree);
                x4=cutX(numFour);
                y4=cutY(numFour);
                x5=cutX(numFive);
                y5=cutY(numFive);
                if(x1==x2 && y1==y2) {
                    System.out.println("points coincide");
                }
                else {
                    l1=Math.sqrt(Math.pow(x3-x4,2)+Math.pow(y3-y4,2));
                    l2=Math.sqrt(Math.pow(x3-x5,2)+Math.pow(y3-y5,2));
                    l3=Math.sqrt(Math.pow(x4-x5,2)+Math.pow(y4-y5,2));
                    L1=l1*l1;  
                    L2=l2*l2;
                    L3=l3*l3;
                    if(traWeather()) {
                        if(parWeather(x1,y1,x2,y2,x3,y3,x4,y4)) {
                            if(sameWeather(x1,y1,x2,y2,x3,y3,x4,y4)) {
                                System.out.print("The point is on the edge of the triangle");
                            }
                            else {
                                pX2=(-((x3-x5)*(x2*y1-x1*y2)-(x1-x2)*(x5*y3-x3*y5))/((y3-y5)*(x1-x2)-(y1-y2)*(x3-x5)));  //x1y1x2y2 和 x3y3x5y5
                                pY2=(-((y3-y5)*(y2*x1-y1*x2)-(y1-y2)*(y5*x3-y3*x5))/((x3-x5)*(y1-y2)-(x1-x2)*(y3-y5)));
                                pX3=(-((x5-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y5-x5*y4))/((y5-y4)*(x1-x2)-(y1-y2)*(x5-x4)));  //x1y1x2y2 和 x4y4x5y5
                                pY3=(-((y5-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x5-y5*x4))/((x5-x4)*(y1-y2)-(x1-x2)*(y5-y4)));
                                if((x3==x5 && ((pY2>=y3 && pY1<=y5) || (pY2>=y5 && pY2<=y3)))) {  //x3y3与x5y5构成的直线垂直
                                    if(pY2!=y3 && pY2!=y5) {
                                        countTwo++;
                                    }
                                    if(pY2==y3 && wrongPiont1==0) {
                                        wrongPiont1++;
                                    }
                                    if(pY2==y5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                if(x3!=x5 && ((pX2>=x3 && pX2<=x5) || (pX2>=x5 && pX2<=x3))) {  //不垂直
                                    if(pX2!=x3 && pX2!=x5) {
                                        countTwo++;
                                    }
                                    if(pX2==x3 && wrongPiont1==0) {
                                        wrongPiont1++;
                                    }
                                    if(pX2==x5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                if((x4==x5 && ((pY3>=y4 && pY3<=y5) || (pY3>=y5 && pY3<=y4)))) {  //x4y4与x5y5构成的直线垂直
                                    if(pY3!=y3 && pY3!=y4) {
                                        countThree++;
                                    }
                                    if(pY3==y4 && wrongPiont1==0) {
                                        wrongPiont2++;
                                    }
                                    if(pY3==y5 && wrongPiont2==0) {
                                        wrongPiont3++;
                                    }
                                }
                                if(x4!=x5 && ((pX3>=x4 && pX3<=x5) || (pX3>=x5 && pX3<=x4))) {  //不垂直
                                    if(pX3!=x4 && pX3!=x5) {
                                        countThree++;
                                    }
                                    if(pX3==x4 && wrongPiont2==0) {
                                        wrongPiont2++;
                                    }
                                    if(pX3==x5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                wrongPiont=wrongPiont3+wrongPiont2+wrongPiont1;
                                allCount=countOne+countTwo+countThree;
                                if(wrongPiont+allCount==0) {
                                    System.out.print("0");
                                }
                                if(wrongPiont==1) {
                                    System.out.print("1");
                                }
                                else {
                                    System.out.print(allCount+" ");
                                    S=0.5*Math.abs((x4*y5-x5*y4)+(x5*y3-x3*y5)+(x3*y4-x4*y3));
                                    s1=0.5*Math.abs((pX3*pY2-pX2*pY3)+(pX2*y5-x5*pY2)+(x5*pY3-pX3*y5));
                                    s2=S-s1;
                                    if(Math.abs(s2)>Math.abs(s1)) {
                                        temp=s2;
                                        s2=s1;
                                        s1=temp;
                                    }
                                    s1=Math.abs(s1);
                                    s2=Math.abs(s2);
                                    System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                }
                            }
                        }
                        
                        else if(parWeather(x1,y1,x2,y2,x3,y3,x5,y5)) {
                            if(sameWeather(x1,y1,x2,y2,x3,y3,x5,y5)) {
                                System.out.print("The point is on the edge of the triangle");
                            }
                            else {
                                pX1=(-((x3-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y3-x3*y4))/((y3-y4)*(x1-x2)-(y1-y2)*(x3-x4)));  //x1y1x2y2 和 x3y3x4y4
                                pY1=(-((y3-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x3-y3*x4))/((x3-x4)*(y1-y2)-(x1-x2)*(y3-y4)));     
                                pX3=(-((x5-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y5-x5*y4))/((y5-y4)*(x1-x2)-(y1-y2)*(x5-x4)));  //x1y1x2y2 和 x4y4x5y5
                                pY3=(-((y5-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x5-y5*x4))/((x5-x4)*(y1-y2)-(x1-x2)*(y5-y4)));
                                if((x3==x4 && ((pY1>=y3 && pY1<=y4) || (pY1>=y4 && pY1<=y3))))  {   //x3y3与x4y4构成的直线垂直
                                    if(pY1!=y3 && pY1!=y4) {
                                        countOne++;
                                    }
                                    if(pY1==y3) {
                                        wrongPiont1++;
                                    }
                                    if(pY1==y4) {
                                        wrongPiont2++;
                                    }
                                }
                                if(x3!=x4 && ((pX1>=x3 && pX1<=x4) || (pX1>=x4 && pX1<=x3))) {  //不垂直
                                    if(pX1!=x3 && pX1!=x4) {
                                        countOne++;
                                    }
                                    if(pX1==x3) {
                                        wrongPiont1++;
                                    }
                                    if(pX1==x4) {
                                        wrongPiont2++;
                                    }
                                }
                                if((x4==x5 && ((pY3>=y4 && pY3<=y5) || (pY3>=y5 && pY3<=y4)))) {  //x4y4与x5y5构成的直线垂直
                                    if(pY3!=y3 && pY3!=y4) {
                                        countThree++;
                                    }
                                    if(pY3==y4 && wrongPiont2==0) {
                                        wrongPiont2++;
                                    }
                                    if(pY3==y5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                if(x4!=x5 && ((pX3>=x4 && pX3<=x5) || (pX3>=x5 && pX3<=x4))) {  //不垂直
                                    if(pX3!=x4 && pX3!=x5) {
                                        countThree++;
                                    }
                                    if(pX3==x4 && wrongPiont2==0) {
                                        wrongPiont2++;
                                    }
                                    if(pX3==x5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                wrongPiont=wrongPiont3+wrongPiont2+wrongPiont1;
                                allCount=countOne+countTwo+countThree;
                                if(wrongPiont+allCount==0) {
                                    System.out.print("0");
                                }
                                else if(wrongPiont==1) {
                                    System.out.println("1");
                                }
                                else {
                                    System.out.print(allCount+" ");
                                    S=0.5*Math.abs((x4*y5-x5*y4)+(x5*y3-x3*y5)+(x3*y4-x4*y3));
                                    s1=0.5*Math.abs((pX1*pY3-pX3*pY1)+(pX3*y4-x4*pY3)+(x4*pY1-pX1*y4));
                                    s2=S-s1;
                                    if(Math.abs(s2)>Math.abs(s1)) {
                                        temp=s2;
                                        s2=s1;
                                        s1=temp;
                                    }
                                    s1=Math.abs(s1);
                                    s2=Math.abs(s2);
                                    System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                }
                            }
                        }
                        
                        else if(parWeather(x1,y1,x2,y2,x4,y4,x5,y5)) {
                            if(sameWeather(x1,y1,x2,y2,x4,y4,x5,y5)) {
                                System.out.print("The point is on the edge of the triangle");
                            }
                            else {
                                pX1=(-((x3-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y3-x3*y4))/((y3-y4)*(x1-x2)-(y1-y2)*(x3-x4)));  //x1y1x2y2 和 x3y3x4y4
                                pY1=(-((y3-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x3-y3*x4))/((x3-x4)*(y1-y2)-(x1-x2)*(y3-y4)));     
                                pX2=(-((x3-x5)*(x2*y1-x1*y2)-(x1-x2)*(x5*y3-x3*y5))/((y3-y5)*(x1-x2)-(y1-y2)*(x3-x5)));  //x1y1x2y2 和 x3y3x5y5
                                pY2=(-((y3-y5)*(y2*x1-y1*x2)-(y1-y2)*(y5*x3-y3*x5))/((x3-x5)*(y1-y2)-(x1-x2)*(y3-y5)));
                                if((x3==x4 && ((pY1>=y3 && pY1<=y4) || (pY1>=y4 && pY1<=y3))))  {   //x3y3与x4y4构成的直线垂直
                                    if(pY1!=y3 && pY1!=y4) {
                                        countOne++;
                                    }
                                    if(pY1==y3) {
                                        wrongPiont1++;
                                    }
                                    if(pY1==y4) {
                                        wrongPiont2++;
                                    }
                                }
                                if(x3!=x4 && ((pX1>=x3 && pX1<=x4) || (pX1>=x4 && pX1<=x3))) {  //不垂直
                                    if(pX1!=x3 && pX1!=x4) {
                                        countOne++;
                                    }
                                    if(pX1==x3) {
                                        wrongPiont1++;
                                    }
                                    if(pX1==x4) {
                                        wrongPiont2++;
                                    }
                                }
                                if((x3==x5 && ((pY2>=y3 && pY1<=y5) || (pY2>=y5 && pY2<=y3)))) {  //x3y3与x5y5构成的直线垂直
                                    if(pY2!=y3 && pY2!=y5) {
                                        countTwo++;
                                    }
                                    if(pY2==y3 && wrongPiont1==0) {
                                        wrongPiont1++;
                                    }
                                    if(pY2==y5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                if(x3!=x5 && ((pX2>=x3 && pX2<=x5) || (pX2>=x5 && pX2<=x3))) {  //不垂直
                                    if(pX2!=x3 && pX2!=x5) {
                                        countTwo++;
                                    }
                                    if(pX2==x3 && wrongPiont1==0) {
                                        wrongPiont1++;
                                    }
                                    if(pX2==x5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                wrongPiont=wrongPiont3+wrongPiont2+wrongPiont1;
                                allCount=countOne+countTwo+countThree;
                                if(wrongPiont+allCount==0) {
                                    System.out.print("0");
                                }
                                else if(wrongPiont==1) {
                                    System.out.println("1");
                                }
                                else {
                                    System.out.print(allCount+" ");
                                    S=0.5*Math.abs((x4*y5-x5*y4)+(x5*y3-x3*y5)+(x3*y4-x4*y3));
                                    s1=0.5*Math.abs((pX1*pY2-pX2*pY1)+(pX2*y3-x3*pY2)+(x3*pY1-pX1*y3));
                                    s2=S-s1;
                                    if(Math.abs(s2)>Math.abs(s1)) {
                                        temp=s2;
                                        s2=s1;
                                        s1=temp;
                                    }
                                    s1=Math.abs(s1);
                                    s2=Math.abs(s2);
                                    System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                }
                            }
                        }
                        
                        else {
                        pX1=(-((x3-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y3-x3*y4))/((y3-y4)*(x1-x2)-(y1-y2)*(x3-x4)));  //x1y1x2y2 和 x3y3x4y4
                        pY1=(-((y3-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x3-y3*x4))/((x3-x4)*(y1-y2)-(x1-x2)*(y3-y4)));     
                        pX2=(-((x3-x5)*(x2*y1-x1*y2)-(x1-x2)*(x5*y3-x3*y5))/((y3-y5)*(x1-x2)-(y1-y2)*(x3-x5)));  //x1y1x2y2 和 x3y3x5y5
                        pY2=(-((y3-y5)*(y2*x1-y1*x2)-(y1-y2)*(y5*x3-y3*x5))/((x3-x5)*(y1-y2)-(x1-x2)*(y3-y5)));
                        pX3=(-((x5-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y5-x5*y4))/((y5-y4)*(x1-x2)-(y1-y2)*(x5-x4)));  //x1y1x2y2 和 x4y4x5y5
                        pY3=(-((y5-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x5-y5*x4))/((x5-x4)*(y1-y2)-(x1-x2)*(y5-y4)));
//                        System.out.println(pX1+" "+pY1+" "+pX2+" "+pY2+" "+pX3+" "+pY3);
                        //三角形的三个顶点       
                        //判断交点是否在线段内部
                        if((x3==x4 && ((pY1>=y3 && pY1<=y4) || (pY1>=y4 && pY1<=y3))))  {   //x3y3与x4y4构成的直线垂直
                            if(pY1!=y3 && pY1!=y4) {
                                countOne++;
                            }
                            if(pY1==y3 && wrongPiont1==0) {
                                wrongPiont1++;
                            }
                            if(pY1==y4 && wrongPiont2==0) {
                                wrongPiont2++;
                            }
                        }
                        if(x3!=x4 && ((pX1>=x3 && pX1<=x4) || (pX1>=x4 && pX1<=x3))) {  //不垂直
                            if(pX1!=x3 && pX1!=x4) {
                                countOne++;
                            }
                            if(pX1==x3 && wrongPiont1==0) {
                                wrongPiont1++;
                            }
                            if(pX1==x4 && wrongPiont2==0) {
                                wrongPiont2++;
                            }
                        }
                        if((x3==x5 && ((pY2>=y3 && pY1<=y5) || (pY2>=y5 && pY2<=y3)))) {  //x3y3与x5y5构成的直线垂直
                            if(pY2!=y3 && pY2!=y5) {
                                countTwo++;
                            }
                            if(pY2==y3 && wrongPiont1==0) {
                                wrongPiont1++;
                            }
                            if(pY2==y5 && wrongPiont3==0) {
                                wrongPiont3++;
                            }
                        }
                        if(x3!=x5 && ((pX2>=x3 && pX2<=x5) || (pX2>=x5 && pX2<=x3))) {  //不垂直
                            if(pX2!=x3 && pX2!=x5) {
                                countTwo++;
                            }
                            if(pX2==x3 && wrongPiont1==0) {
                                wrongPiont1++;
                            }
                            if(pX2==x5 && wrongPiont3==0) {
                                wrongPiont3++;
                            }
                        }
                        if((x4==x5 && ((pY3>=y4 && pY3<=y5) || (pY3>=y5 && pY3<=y4)))) {  //x4y4与x5y5构成的直线垂直
                            if(pY3!=y3 && pY3!=y4) {
                                countThree++;
                            }
                            if(pY3==y4 && wrongPiont2==0) {
                                wrongPiont2++;
                            }
                            if(pY3==y5 && wrongPiont3==0) {
                                wrongPiont3++;
                            }
                        }
                        if(x4!=x5 && ((pX3>=x4 && pX3<=x5) || (pX3>=x5 && pX3<=x4))) {  //不垂直
                            if(pX3!=x4 && pX3!=x5) {
                                countThree++;
                            }
                            if(pX3==x4 && wrongPiont2==0) {
                                wrongPiont2++;
                            }
                            if(pX3==x5 && wrongPiont3==0) {
                                wrongPiont3++;
                            }
                        }
                        wrongPiont=wrongPiont1+wrongPiont2+wrongPiont3;
                        allCount=countOne+countTwo+countThree;
                        if(allCount+wrongPiont==0) {
                                System.out.print("0");
                        }
                        else if(wrongPiont==1 && allCount==0) {
                            System.out.print("1");
                        }
                        else if(wrongPiont!=2){
                            System.out.print((allCount+wrongPiont)+" ");
                        }
                        if(wrongPiont<=1) {
                            if(allCount+wrongPiont==2) {
                                if(wrongPiont==0) {
                                    if(countOne==1 && countTwo==1) {
                                        //x3 pX1 pX2
                                        S=0.5*Math.abs((x4*y5-x5*y4)+(x5*y3-x3*y5)+(x3*y4-x4*y3));
                                        s1=0.5*Math.abs((pX1*pY2-pX2*pY1)+(pX2*y3-x3*pY2)+(x3*pY1-pX1*y3));
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        s1=Math.abs(s1);
                                        s2=Math.abs(s2);
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                    if(countOne==1 && countThree==1) {
                                        //x4 pX1 pX3
                                        S=0.5*Math.abs(x4*y5+x5*y3+x3*y4-x4*y3-x5*y4-x3*y5);
                                        s1=0.5*Math.abs((pX1*pY3-pX3*pY1)+(pX3*y4-x4*pY3)+(x4*pY1-pX1*y4));
//                                        S=0.5*Math.abs(x4*y2+x2*y3+x3*y4-x4*y3-x2*y4-x3*y2);
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        System.out.print(Math.abs(s1)+" "+Math.abs(s2));
                                    }
                                    if(countTwo==1 && countThree==1) {
                                        //x5 pX2 pX3
                                        S=0.5*Math.abs((x4*y5-x5*y4)+(x5*y3-x3*y5)+(x3*y4-x4*y3));
                                        s1=0.5*Math.abs((pX3*pY2-pX2*pY3)+(pX2*y5-x5*pY2)+(x5*pY3-pX3*y5));
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        s1=Math.abs(s1);
                                        s2=Math.abs(s2);
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                }
                                else if(wrongPiont==1) {
//                                    System.out.println("1");
                                    if(wrongPiont1==1) {
                                        //px3 x3 x4
//                                        System.out.println(pX3+" "+pY3);
                                        S=0.5*Math.abs(x4*y5+x5*y3+x3*y4-x4*y3-x5*y4-x3*y5);
                                        s1=0.5*Math.abs(x4*pY3+pX3*y3+x3*y4-x4*y3-pX3*y4-x3*pY3);  
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        s1=Math.abs(s1);
                                        s2=Math.abs(s2);
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                    if(wrongPiont2==1) {
//                                        System.out.println(pX2+" "+pY2);
                                        S=0.5*Math.abs(x4*y5+x5*y3+x3*y4-x4*y3-x5*y4-x3*y5);
                                        s1=0.5*Math.abs(x4*pY2+pX2*y3+x3*y4-x4*y3-pX2*y4-x3*pY2);   //px2 x4 x3
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        s1=Math.abs(s1);
                                        s2=Math.abs(s2);
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                    if(wrongPiont3==1) {
//                                        System.out.println(pX1+" "+pY1);
                                        S=0.5*Math.abs(x4*y5+x5*y3+x3*y4-x4*y3-x5*y4-x3*y5);
                                        s1=0.5*Math.abs((pX1*y5-x5*pY1)+(x5*y4-x4*y5)+(x4*pY1-pX1*y4));
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        s1=Math.abs(s1);
                                        s2=Math.abs(s2);
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                }
                            }
                        }
                        }
                        if(wrongPiont==2) {
                            System.out.print("The point is on the edge of the triangle");  //*
                        }
                    }
                    else {
                        System.out.println("data error");
                    }
                }
            }
            else {
                System.out.println("Wrong Format");
            }
        }
        else {
            if(allBlank<4) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
            else if(allBlank>4) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                numFive=cutArr();
                numSix=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour) && checkNum(numFive) && checkNum(numSix)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
        }
    }
    
    //case 5
    public void outWeather() {
        if(numData(numBlank())) {
            numOne=cutArr();
            numTwo=cutArr();
            numThree=cutArr();
            numFour=cutArr();
            if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour)) {
                x1=cutX(numOne);
                y1=cutY(numOne);
                x2=cutX(numTwo);
                y2=cutY(numTwo);
                x3=cutX(numThree);
                y3=cutY(numThree);
                x4=cutX(numFour);
                y4=cutY(numFour);
        
            
                    l1=Math.sqrt(Math.pow(x2-x3,2)+Math.pow(y2-y3,2));
                    l2=Math.sqrt(Math.pow(x3-x4,2)+Math.pow(y3-y4,2));
                    l3=Math.sqrt(Math.pow(x2-x4,2)+Math.pow(y2-y4,2));
                    L1=l1*l1;
                    L2=l2*l2;
                    L3=l3*l3;
                    if(traWeather()) {
                        S=0.5*Math.abs(x4*y2+x2*y3+x3*y4-x4*y3-x2*y4-x3*y2);
                        s1=0.5*Math.abs(x1*y2+x2*y3+x3*y1-x1*y3-x2*y1-x3*y2);  
                        s2=0.5*Math.abs(x1*y4+x4*y3+x3*y1-x1*y3-x4*y1-x3*y4);
                        s3=0.5*Math.abs(x1*y2+x2*y4+x4*y1-x1*y4-x2*y1-x4*y2);
                        if(s1==0 || s2==0 || s3==0) {
                            System.out.println("on the triangle");
                        }
                        else if(S==s1+s2+s3) {
                            System.out.println("in the triangle");
                        }
                        else {
                            System.out.println("outof the triangle");
                        }
                    }
                    else {
                        System.out.println("data error");
                    }
                
            }
            else {
                System.out.println("Wrong Format");
            }
        }
        else {
            if(allBlank<4) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
            else if(allBlank>4) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                numFive=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour) && checkNum(numFive)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
        }
    }
}

 

PTA题目集4 7-3点线形系列3-三角形的计算

从我的做题经验来看，本体任务点有三角形是否成立的判断、判断点是否在三角形内部，判断三角形类型。

判断三角形是否成立，可以算出三条边的面积，然后依次判断两边之和是否大于第三边。点是否在三角形的内部有两种方法可以判断1.面积法 将三角形划分为三个小三角形判断算出来的面积是否与大三角形相等。2.射线法由第一个点往任一方向做一射线，射线与三角形的边的交点（不含点本身）数量如果为1，则在三角形内部。如果交点有两个或0个，则在三角形之外

类图：

 

代码：

 

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        cauTangle what = new cauTangle();
        what.option();
    }
}

class cauTangle {
    
    Scanner in = new Scanner(System.in);
    
    String arr;  //输入的字符串
    String cutArr;  //坐标
    String head;  //字符串前缀
    String mark;  //英文冒号
    String choice;  //选项
    
    int wrong=0;
    int Choice=0;  //选项
    int allBlank=0;  //空格的数量
    
    double l1=0;
    double l2=0;
    double l3=0;
    
    double L1=0;
    double L2=0;
    double L3=0;
    
    double s1=0;
    double s2=0;
    double s3=0;
    double S=0;
    
    double x1=0;
    double y1=0;
    double x2=0;
    double y2=0;
    double x3=0;
    double y3=0;
    double x4=0;
    double y4=0;
    double x5=0;
    double y5=0;
    
    String numOne;
    String numTwo;
    String numThree;
    String numFour;
    String numFive;
    String numSix;
    
    public void option() {
        inPut();
        if(arr.length()==1) {
            System.out.println("Wrong Format");
            wrong++;
        }
        else {
            cutHead();
            cutOption();
            if(arr.charAt(0)==' ') {
                System.out.println("Wrong Format");
                wrong++;
            }
        }
        if((wrong==0) && (choice.charAt(0)=='1' || choice.charAt(0)=='2' || choice.charAt(0)=='3' || choice.charAt(0)=='4' || choice.charAt(0)=='5')) {
            Choice=Integer.parseInt(choice);
        }
        else {
            System.out.println("Wrong Format");
            wrong++;
        }
        if(wrong==0) {
            switch(Choice) {
                case 1:
                    isqWeather();
                    break;
                case 2:
                    algorTra();
                    break;
                case 3:
                    whatAngle();
                    break;
                case 4:
                    centreNum();
                    break;
                case 5:
                    outWeather();
            }
        }
    }
    
    //输入字符串
    public void inPut() {
        arr=in.nextLine();
    }
    
    //切去头部
    public void cutHead() {
        head=arr.substring(0,2);
        arr=arr.substring(2,arr.length());
    }
    
    //提取选项与符号
    public void cutOption() {
        choice=head.substring(0,1);
        mark=head.substring(1,2);
    }
    
    //切割坐标
    public String cutArr() {
        int blankCount=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==' ') {
                cutArr=arr.substring(0,i);
                arr=arr.substring(i+1,arr.length());
                blankCount++;
                break;
            }
        }
        if(blankCount==0) {
            cutArr=arr.substring(0,arr.length());
        }
        return cutArr;
    }
    
    //计算空格的个数
    public int numBlank() {
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==' ' && i!=arr.length()-1) {
            allBlank++;
            }
        }
        return allBlank;
    }
    
    //判断输入数据是多于所需数据
    public boolean numData(int n) {
        switch(Choice) {
            case 1:
                if(allBlank!=2) {
                    return false;
                }
                else {
                    return true;
                }
            case 2:
                if(allBlank!=2) {
                    return false;
                }
                else {
                    return true;
                }
            case 3:
                if(allBlank!=2) {
                    return false;
                }
                else {
                    return true;
                }
            case 4:
                if(allBlank!=4) {
                    return false;
                }
                else {
                    return true;
                }
            case 5:
                if(allBlank!=3) {
                    return false;
                }
                else {
                    return true;
                }        
        }
        return false;
    }
    
    //切割得x的值
    public double cutX(String arr) {
        String X;
        double x=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==',') {
                X=arr.substring(0,i);
                x=Double.parseDouble(X);
                break;
            }
        }
        return x;
    }
        
    //切割得y的值
    public double cutY(String arr) {
        String Y;
        double y=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==',') {
                Y=arr.substring(i+1,arr.length());
                y=Double.parseDouble(Y);
                break;
            }
        }
        return y;
    }
    
    //检查格式是否错误
    public boolean checkNum(String num) {
        int countOne=0;
        int count=0;
        int j=0;
        //坐标为空
        if(num=="") {
            return false;
        }
        //冒号错误
        if(mark.charAt(0)!=':') {
            return false;
        }
        //判断逗号数量是否错误
        for(int i=0;i<num.length();i++) {
            if(num.charAt(i)==',') {
                countOne++;
            }
        }
        if(countOne!=1) {
            return false;
        }
        //判断小数点数量是否错误
        while(num.charAt(j)!=',') {
            if(num.charAt(j)=='.') {
                count++;
            }
            j++;
        }
        if(count>1) {
            return false;
        }
        count=0;
        while(j<num.length()) {
            if(num.charAt(j)=='.') {
                count++;
            }
            j++;
        }
        if(count>1) {
            return false;
        }
        for(int i=0;i<num.length();i++) {
            
            //非法字符
            if(num.charAt(i)!=',' && num.charAt(i)!='+' && num.charAt(i)!='-' && num.charAt(i)!='.' && (num.charAt(i)<48 || num.charAt(i)>57)) {
                return false;
            }
            //x:00,01
            if((i==0) && (num.charAt(i)=='0' && (num.charAt(i+1)!='.' && num.charAt(i+1)!=','))) {
                return false;
            }
            //y:00,01
            if((num.charAt(i)==',' && i!=num.length()-1 && num.charAt(i+1)=='0' && i+2<num.length()) && (num.charAt(i+2)!='.'))  {
                return false;
            }
            //+,-后面必须接数字
            if((i==0) && ((num.charAt(i)!='+' && num.charAt(i)!='-') && (num.charAt(i)<48 || num.charAt(i)>57))) {
                return false;
            }
            //不得有多个+,-
            if((num.charAt(i)=='+' || num.charAt(i)=='-') && (i!=0 && num.charAt(i-1)!=',')) {
                return false;
            }
            //小数点后必须接数字
            if((num.charAt(i)=='.') && (i==num.length()-1 || (num.charAt(i+1)<48 || num.charAt(i+1)>57))) {
                return false;
            }
            if((num.charAt(i)==',') && ((i==num.length()-1 || (num.charAt(i-1)<48 || num.charAt(i-1)>57)) || ((num.charAt(i+1)!='+' && num.charAt(i+1)!= '-') && (num.charAt(i+1)<48 || num.charAt(i+1)>57)))) {
                return false;
            }
            if(num.charAt(num.length()-1)==',') {
                return false;
            }
        }
        return true;
    }
    public boolean traWeather() {
        if(l1+l2>l3 && l2+l3>l1 && l1+l3>l2) {
            return true;
        }
        else {
            return false;
        }
    }
    public boolean parWeather(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {
        double k1=0;
        double k2=0;
        if(x3!=x4 && x3!=x4) {
            k1=(y3-y4)/(x3-x4);
            k2=(y1-y2)/(x1-x2);
            if(k1==k2) {
                return true;
            }
        }
        if(x3!=x4 && x3==x4) {
            return false;
        }
        if(x3==x4 && x3!=x4) {
            return false;
        }
        if(x3==x4 && x1==x2) {
            return true;
        }
        return false;
    }
    public boolean sameWeather(double x1,double y1,double x2,double y2,double x3,double y3,double x4,double y4) {
        double k1=0;
        double k2=0;
        double k3=0;
        if(x3==x4)
            if(x1==x3) {
                return true;
            }
            else {
                return false;
        }
        else {
            k1=(y3-y4)/(x3-x4);
            k2=(y2-y3)/(x2-x3);
            k3=(y2-y4)/(x2-x4);
            if(k1==k2 || k3==k1) {
                return true;
            }
            else {
                return false;
            }
        }
    }
    
    //case 1
    public void isqWeather() {        
        if(numData(numBlank())) {
            numOne=cutArr();
            numTwo=cutArr();
            numThree=cutArr();
            if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree)) {
                x1=cutX(numOne);
                y1=cutY(numOne);
                x2=cutX(numTwo);
                y2=cutY(numTwo);
                x3=cutX(numThree);
                y3=cutY(numThree);
                l1=Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
                l2=Math.sqrt(Math.pow(x2-x3,2)+Math.pow(y2-y3,2));
                l3=Math.sqrt(Math.pow(x1-x3,2)+Math.pow(y1-y3,  2));
                if(traWeather()) {
                    if((Math.abs(l1-l2)<0.000001) || (Math.abs(l1-l3)<0.000001) || (Math.abs(l2-l3)<0.000001)) {
                        System.out.print("true"+" ");
                    }
                    else {
                        System.out.print("false"+" ");
                    }
                    if(l1==l2 && l2==l3) {
                        System.out.print("true");
                    }
                    else {
                        System.out.print("false");
                    }
                }
                else {
                    System.out.println("data error");
                }
            }
            else {
                System.out.println("Wrong Format");
            }
        }
        else {
            if(allBlank<2) {
                numOne=cutArr();
                numTwo=cutArr();
                if(checkNum(numOne) && checkNum(numTwo)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
            else if(allBlank>2) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
        }
    }
    
    //case 2
    public void algorTra() {        
        double x=0;
        double y=0;
        double area=0;
        double c=0;
        
        if(numData(numBlank())) {
            numOne=cutArr();
            numTwo=cutArr();
            numThree=cutArr();
            if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree)) {
                x1=cutX(numOne);
                y1=cutY(numOne);
                x2=cutX(numTwo);
                y2=cutY(numTwo);
                x3=cutX(numThree);
                y3=cutY(numThree);
                l1=Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
                l2=Math.sqrt(Math.pow(x2-x3,2)+Math.pow(y2-y3,2));
                l3=Math.sqrt(Math.pow(x1-x3,2)+Math.pow(y1-y3,2));
                if(traWeather()) {
                    x=(x1+x2+x3)/3;
                    y=(y1+y2+y3)/3;
                    area=0.5*(x1*y2-x1*y3+x2*y3-x2*y1+x3*y1-x2*y2);  
                    c=l1+l2+l3;
                    System.out.println((double)Math.round(c*1000000)/1000000+" "+(double)Math.round(area*1000000)/1000000+" "+(double)Math.round(x*1000000)/1000000+","+(double)Math.round(y*1000000)/1000000);
                }
                else {
                    System.out.println("data error");
                }
            }
            else {
                System.out.println("Wrong Format");
            }
        }
        else {
            if(allBlank<2) {
                numOne=cutArr();
                numTwo=cutArr();
                if(checkNum(numOne) && checkNum(numTwo)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
            else if(allBlank>2) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
        }
    }
    
    //case 3
    public void whatAngle() {
        
        if(numData(numBlank())) {
            numOne=cutArr();
            numTwo=cutArr();
            numThree=cutArr();
            if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree)) {
                x1=cutX(numOne);
                y1=cutY(numOne);
                x2=cutX(numTwo);
                y2=cutY(numTwo);
                x3=cutX(numThree);
                y3=cutY(numThree);
                l1=Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
                l2=Math.sqrt(Math.pow(x2-x3,2)+Math.pow(y2-y3,2));
                l3=Math.sqrt(Math.pow(x1-x3,2)+Math.pow(y1-y3,2));
                L1=l1*l1;
                L2=l2*l2;
                L3=l3*l3;
                if(traWeather()) {
                    //钝角
                    if((L1-(L2+L3))>0.000001 || (L2-L1-L3)>0.000001 || (L3-L1-L2)>0.000001) {
                        System.out.print("true"+" ");
                    }
                    else {
                        System.out.print("false"+" ");
                    }
                    //直角
                    if(Math.abs(L1-(L2+L3))<0.00001 || Math.abs(L2-(L1+L3))<0.00001 || Math.abs(L3-(L1+L2))<0.00001) {
                        System.out.print("true"+" ");
                    }
                    else {
                        System.out.print("false"+" ");
                    }
                    //锐角
                    if(L1-L2-L3<-0.000001 && L2-L1-L3<-0.000001 && L3-L1-L2<-0.000001) {
                        System.out.print("true");
                    }
                    else {
                        System.out.print("false");
                    }
                }
                else {
                    System.out.println("data error");
                }
            }
        }
        else {
            if(allBlank<2) {
                numOne=cutArr();
                numTwo=cutArr();
                if(checkNum(numOne) && checkNum(numTwo)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
            else if(allBlank>2) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
        }
    }
    
    //case 4
    public void centreNum() {        
        //第一条直线与每条边的交点
        double pX1=0;
        double pY1=0;
        double pX2=0;
        double pY2=0;
        double pX3=0;
        double pY3=0;
        
        double S=0;
        double s1=0;
        double s2=0;
        double temp=0;
        
        int countOne=0;
        int countTwo=0;
        int countThree=0;
        int wrongPiont1=0;
        int wrongPiont2=0;
        int wrongPiont3=0;
        int allCount=0;
        int wrongPiont=0;
        int num=0;
        
        
        if(numData(numBlank())) {
            numOne=cutArr();
            numTwo=cutArr();
            numThree=cutArr();
            numFour=cutArr();
            numFive=cutArr();
            if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour) && checkNum(numFive)) {
                x1=cutX(numOne);
                y1=cutY(numOne);
                x2=cutX(numTwo);
                y2=cutY(numTwo);
                x3=cutX(numThree);
                y3=cutY(numThree);
                x4=cutX(numFour);
                y4=cutY(numFour);
                x5=cutX(numFive);
                y5=cutY(numFive);
                if(x1==x2 && y1==y2) {
                    System.out.println("points coincide");
                }
                else {
                    l1=Math.sqrt(Math.pow(x3-x4,2)+Math.pow(y3-y4,2));
                    l2=Math.sqrt(Math.pow(x3-x5,2)+Math.pow(y3-y5,2));
                    l3=Math.sqrt(Math.pow(x4-x5,2)+Math.pow(y4-y5,2));
                    L1=l1*l1;  
                    L2=l2*l2;
                    L3=l3*l3;
                    if(traWeather()) {
                        if(parWeather(x1,y1,x2,y2,x3,y3,x4,y4)) {
                            if(sameWeather(x1,y1,x2,y2,x3,y3,x4,y4)) {
                                System.out.print("The point is on the edge of the triangle");
                            }
                            else {
                                pX2=(-((x3-x5)*(x2*y1-x1*y2)-(x1-x2)*(x5*y3-x3*y5))/((y3-y5)*(x1-x2)-(y1-y2)*(x3-x5)));  //x1y1x2y2 和 x3y3x5y5
                                pY2=(-((y3-y5)*(y2*x1-y1*x2)-(y1-y2)*(y5*x3-y3*x5))/((x3-x5)*(y1-y2)-(x1-x2)*(y3-y5)));
                                pX3=(-((x5-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y5-x5*y4))/((y5-y4)*(x1-x2)-(y1-y2)*(x5-x4)));  //x1y1x2y2 和 x4y4x5y5
                                pY3=(-((y5-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x5-y5*x4))/((x5-x4)*(y1-y2)-(x1-x2)*(y5-y4)));
                                if((x3==x5 && ((pY2>=y3 && pY1<=y5) || (pY2>=y5 && pY2<=y3)))) {  //x3y3与x5y5构成的直线垂直
                                    if(pY2!=y3 && pY2!=y5) {
                                        countTwo++;
                                    }
                                    if(pY2==y3 && wrongPiont1==0) {
                                        wrongPiont1++;
                                    }
                                    if(pY2==y5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                if(x3!=x5 && ((pX2>=x3 && pX2<=x5) || (pX2>=x5 && pX2<=x3))) {  //不垂直
                                    if(pX2!=x3 && pX2!=x5) {
                                        countTwo++;
                                    }
                                    if(pX2==x3 && wrongPiont1==0) {
                                        wrongPiont1++;
                                    }
                                    if(pX2==x5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                if((x4==x5 && ((pY3>=y4 && pY3<=y5) || (pY3>=y5 && pY3<=y4)))) {  //x4y4与x5y5构成的直线垂直
                                    if(pY3!=y5 && pY3!=y4) {
                                        countThree++;
                                    }
                                    if(pY3==y4 && wrongPiont1==0) {
                                        wrongPiont2++;
                                    }
                                    if(pY3==y5 && wrongPiont2==0) {
                                        wrongPiont3++;
                                    }
                                }
                                if(x4!=x5 && ((pX3>=x4 && pX3<=x5) || (pX3>=x5 && pX3<=x4))) {  //不垂直
                                    if(pX3!=x4 && pX3!=x5) {
                                        countThree++;
                                    }
                                    if(pX3==x4 && wrongPiont2==0) {
                                        wrongPiont2++;
                                    }
                                    if(pX3==x5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                wrongPiont=wrongPiont3+wrongPiont2+wrongPiont1;
                                allCount=countOne+countTwo+countThree;
                                if(wrongPiont+allCount==0) {
                                    System.out.print("0");
                                }
                                if(wrongPiont==1) {
                                    System.out.print("1");
                                }
                                else {
                                    System.out.print(allCount+" ");
                                    S=0.5*Math.abs((x4*y5-x5*y4)+(x5*y3-x3*y5)+(x3*y4-x4*y3));
                                    s1=0.5*Math.abs((pX3*pY2-pX2*pY3)+(pX2*y5-x5*pY2)+(x5*pY3-pX3*y5));
                                    s2=S-s1;
                                    if(Math.abs(s2)>Math.abs(s1)) {
                                        temp=s2;
                                        s2=s1;
                                        s1=temp;
                                    }
                                    System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                }
                            }
                        }
                        
                        else if(parWeather(x1,y1,x2,y2,x3,y3,x5,y5)) {
                            if(sameWeather(x1,y1,x2,y2,x3,y3,x5,y5)) {
                                System.out.print("The point is on the edge of the triangle");
                            }
                            else {
                                pX1=(-((x3-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y3-x3*y4))/((y3-y4)*(x1-x2)-(y1-y2)*(x3-x4)));  //x1y1x2y2 和 x3y3x4y4
                                pY1=(-((y3-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x3-y3*x4))/((x3-x4)*(y1-y2)-(x1-x2)*(y3-y4)));     
                                pX3=(-((x5-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y5-x5*y4))/((y5-y4)*(x1-x2)-(y1-y2)*(x5-x4)));  //x1y1x2y2 和 x4y4x5y5
                                pY3=(-((y5-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x5-y5*x4))/((x5-x4)*(y1-y2)-(x1-x2)*(y5-y4)));
                                if((x3==x4 && ((pY1>=y3 && pY1<=y4) || (pY1>=y4 && pY1<=y3))))  {   //x3y3与x4y4构成的直线垂直
                                    if(pY1!=y3 && pY1!=y4) {
                                        countOne++;
                                    }
                                    if(pY1==y3) {
                                        wrongPiont1++;
                                    }
                                    if(pY1==y4) {
                                        wrongPiont2++;
                                    }
                                }
                                if(x3!=x4 && ((pX1>=x3 && pX1<=x4) || (pX1>=x4 && pX1<=x3))) {  //不垂直
                                    if(pX1!=x3 && pX1!=x4) {
                                        countOne++;
                                    }
                                    if(pX1==x3) {
                                        wrongPiont1++;
                                    }
                                    if(pX1==x4) {
                                        wrongPiont2++;
                                    }
                                }
                                if((x4==x5 && ((pY3>=y4 && pY3<=y5) || (pY3>=y5 && pY3<=y4)))) {  //x4y4与x5y5构成的直线垂直
                                    if(pY3!=y5 && pY3!=y4) {
                                        countThree++;
                                    }
                                    if(pY3==y4 && wrongPiont2==0) {
                                        wrongPiont2++;
                                    }
                                    if(pY3==y5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                if(x4!=x5 && ((pX3>=x4 && pX3<=x5) || (pX3>=x5 && pX3<=x4))) {  //不垂直
                                    if(pX3!=x4 && pX3!=x5) {
                                        countThree++;
                                    }
                                    if(pX3==x4 && wrongPiont2==0) {
                                        wrongPiont2++;
                                    }
                                    if(pX3==x5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                wrongPiont=wrongPiont3+wrongPiont2+wrongPiont1;
                                allCount=countOne+countTwo+countThree;
                                if(wrongPiont+allCount==0) {
                                    System.out.print("0");
                                }
                                else if(wrongPiont==1) {
                                    System.out.println("1");
                                }
                                else {
                                    System.out.print(allCount+" ");
                                    S=0.5*Math.abs((x4*y5-x5*y4)+(x5*y3-x3*y5)+(x3*y4-x4*y3));
                                    s1=0.5*Math.abs((pX1*pY3-pX3*pY1)+(pX3*y4-x4*pY3)+(x4*pY1-pX1*y4));
                                    s2=S-s1;
                                    if(Math.abs(s2)>Math.abs(s1)) {
                                        temp=s2;
                                        s2=s1;
                                        s1=temp;
                                    }
                                    s1=Math.abs(s1);
                                    s2=Math.abs(s2);
                                    System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                }
                            }
                        }
                        
                        else if(parWeather(x1,y1,x2,y2,x4,y4,x5,y5)) {
                            if(sameWeather(x1,y1,x2,y2,x4,y4,x5,y5)) {
                                System.out.print("The point is on the edge of the triangle");
                            }
                            else {
                                pX1=(-((x3-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y3-x3*y4))/((y3-y4)*(x1-x2)-(y1-y2)*(x3-x4)));  //x1y1x2y2 和 x3y3x4y4
                                pY1=(-((y3-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x3-y3*x4))/((x3-x4)*(y1-y2)-(x1-x2)*(y3-y4)));     
                                pX2=(-((x3-x5)*(x2*y1-x1*y2)-(x1-x2)*(x5*y3-x3*y5))/((y3-y5)*(x1-x2)-(y1-y2)*(x3-x5)));  //x1y1x2y2 和 x3y3x5y5
                                pY2=(-((y3-y5)*(y2*x1-y1*x2)-(y1-y2)*(y5*x3-y3*x5))/((x3-x5)*(y1-y2)-(x1-x2)*(y3-y5)));
                                if((x3==x4 && ((pY1>=y3 && pY1<=y4) || (pY1>=y4 && pY1<=y3))))  {   //x3y3与x4y4构成的直线垂直
                                    if(pY1!=y3 && pY1!=y4) {
                                        countOne++;
                                    }
                                    if(pY1==y3) {
                                        wrongPiont1++;
                                    }
                                    if(pY1==y4) {
                                        wrongPiont2++;
                                    }
                                }
                                else if(x3!=x4 && ((pX1>=x3 && pX1<=x4) || (pX1>=x4 && pX1<=x3))) {  //不垂直
                                    if(pX1!=x3 && pX1!=x4) {
                                        countOne++;
                                    }
                                    if(pX1==x3) {
                                        wrongPiont1++;
                                    }
                                    if(pX1==x4) {
                                        wrongPiont2++;
                                    }
                                }
                                if((x3==x5 && ((pY2>=y3 && pY1<=y5) || (pY2>=y5 && pY2<=y3)))) {  //x3y3与x5y5构成的直线垂直
                                    if(pY2!=y3 && pY2!=y5) {
                                        countTwo++;
                                    }
                                    if(pY2==y3 && wrongPiont1==0) {
                                        wrongPiont1++;
                                    }
                                    if(pY2==y5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                else if(x3!=x5 && ((pX2>=x3 && pX2<=x5) || (pX2>=x5 && pX2<=x3))) {  //不垂直
                                    if(pX2!=x3 && pX2!=x5) {
                                        countTwo++;
                                    }
                                    if(pX2==x3 && wrongPiont1==0) {
                                        wrongPiont1++;
                                    }
                                    if(pX2==x5 && wrongPiont3==0) {
                                        wrongPiont3++;
                                    }
                                }
                                wrongPiont=wrongPiont3+wrongPiont2+wrongPiont1;
                                allCount=countOne+countTwo+countThree;
                                if(wrongPiont+allCount==0) {
                                    System.out.print("0");
                                }
                                else if(wrongPiont==1) {
                                    System.out.println("1");
                                }
                                else {
                                    System.out.print(allCount+" ");
                                    S=0.5*Math.abs((x4*y5-x5*y4)+(x5*y3-x3*y5)+(x3*y4-x4*y3));
                                    s1=0.5*Math.abs((pX1*pY2-pX2*pY1)+(pX2*y3-x3*pY2)+(x3*pY1-pX1*y3));
                                    s2=S-s1;
                                    if(Math.abs(s2)>Math.abs(s1)) {
                                        temp=s2;
                                        s2=s1;
                                        s1=temp;
                                    }
                                    s1=Math.abs(s1);
                                    s2=Math.abs(s2);
                                    System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                }
                            }
                        }
                        
                        else {
                        pX1=(-((x3-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y3-x3*y4))/((y3-y4)*(x1-x2)-(y1-y2)*(x3-x4)));  //x1y1x2y2 和 x3y3x4y4
                        pY1=(-((y3-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x3-y3*x4))/((x3-x4)*(y1-y2)-(x1-x2)*(y3-y4)));     
                        pX2=(-((x3-x5)*(x2*y1-x1*y2)-(x1-x2)*(x5*y3-x3*y5))/((y3-y5)*(x1-x2)-(y1-y2)*(x3-x5)));  //x1y1x2y2 和 x3y3x5y5
                        pY2=(-((y3-y5)*(y2*x1-y1*x2)-(y1-y2)*(y5*x3-y3*x5))/((x3-x5)*(y1-y2)-(x1-x2)*(y3-y5)));
                        pX3=(-((x5-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y5-x5*y4))/((y5-y4)*(x1-x2)-(y1-y2)*(x5-x4)));  //x1y1x2y2 和 x4y4x5y5
                        pY3=(-((y5-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x5-y5*x4))/((x5-x4)*(y1-y2)-(x1-x2)*(y5-y4)));
//                        System.out.println(pX1+" "+pY1+" "+pX2+" "+pY2+" "+pX3+" "+pY3);
                        //三角形的三个顶点       
                        //判断交点是否在线段内部
                        if((x3==x4 && ((pY1>=y3 && pY1<=y4) || (pY1>=y4 && pY1<=y3))))  {   //x3y3与x4y4构成的直线垂直
                            if(pY1!=y3 && pY1!=y4) {
                                countOne++;
                            }
                            if(pY1==y3 && wrongPiont1==0) {
                                wrongPiont1++;
                            }
                            if(pY1==y4 && wrongPiont2==0) {
                                wrongPiont2++;
                            }
                        }
                        if(x3!=x4 && ((pX1>=x3 && pX1<=x4) || (pX1>=x4 && pX1<=x3))) {  //不垂直
                            if(pX1!=x3 && pX1!=x4) {
                                countOne++;
                            }
                            if(pX1==x3 && wrongPiont1==0) {
                                wrongPiont1++;
                            }
                            if(pX1==x4 && wrongPiont2==0) {
                                wrongPiont2++;
                            }
                        }
                        if((x3==x5 && ((pY2>=y3 && pY1<=y5) || (pY2>=y5 && pY2<=y3)))) {  //x3y3与x5y5构成的直线垂直
                            if(pY2!=y3 && pY2!=y5) {
                                countTwo++;
                            }
                            if(pY2==y3 && wrongPiont1==0) {
                                wrongPiont1++;
                            }
                            if(pY2==y5 && wrongPiont3==0) {
                                wrongPiont3++;
                            }
                        }
                        if(x3!=x5 && ((pX2>=x3 && pX2<=x5) || (pX2>=x5 && pX2<=x3))) {  //不垂直
                            if(pX2!=x3 && pX2!=x5) {
                                countTwo++;
                            }
                            if(pX2==x3 && wrongPiont1==0) {
                                wrongPiont1++;
                            }
                            if(pX2==x5 && wrongPiont3==0) {
                                wrongPiont3++;
                            }
                        }
                        if((x4==x5 && ((pY3>=y4 && pY3<=y5) || (pY3>=y5 && pY3<=y4)))) {  //x4y4与x5y5构成的直线垂直
                            if(pY3!=y5 && pY3!=y4) {
                                countThree++;
                            }
                            if(pY3==y4 && wrongPiont2==0) {
                                wrongPiont2++;
                            }
                            if(pY3==y5 && wrongPiont3==0) {
                                wrongPiont3++;
                            }
                        }
                        if(x4!=x5 && ((pX3>=x4 && pX3<=x5) || (pX3>=x5 && pX3<=x4))) {  //不垂直
                            if(pX3!=x4 && pX3!=x5) {
                                countThree++;
                            }
                            if(pX3==x4 && wrongPiont2==0) {
                                wrongPiont2++;
                            }
                            if(pX3==x5 && wrongPiont3==0) {
                                wrongPiont3++;
                            }
                        }
                        wrongPiont=wrongPiont1+wrongPiont2+wrongPiont3;
                        allCount=countOne+countTwo+countThree;
                        if(allCount+wrongPiont==0) {
                                System.out.print("0");
                        }
                        else if(wrongPiont==1 && allCount==0) {
                            System.out.print("1");
                        }
                        else if(wrongPiont!=2){
                            System.out.print((allCount+wrongPiont)+" ");
                        }
                        if(wrongPiont<=1) {
                            if(allCount+wrongPiont==2) {
                                if(wrongPiont==0) {
                                    if(countOne==1 && countTwo==1) {
                                        //x3 pX1 pX2
                                        S=0.5*Math.abs((x4*y5-x5*y4)+(x5*y3-x3*y5)+(x3*y4-x4*y3));
                                        s1=0.5*Math.abs((pX1*pY2-pX2*pY1)+(pX2*y3-x3*pY2)+(x3*pY1-pX1*y3));
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        s1=Math.abs(s1);
                                        s2=Math.abs(s2);
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                    else if(countOne==1 && countThree==1) {
                                        //x4 pX1 pX3
                                        S=0.5*Math.abs(x4*y5+x5*y3+x3*y4-x4*y3-x5*y4-x3*y5);
                                        s1=0.5*Math.abs((pX1*pY3-pX3*pY1)+(pX3*y4-x4*pY3)+(x4*pY1-pX1*y4));
//                                        S=0.5*Math.abs(x4*y2+x2*y3+x3*y4-x4*y3-x2*y4-x3*y2);
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                    else if(countTwo==1 && countThree==1) {
                                        //x5 pX2 pX3
                                        S=0.5*Math.abs((x4*y5-x5*y4)+(x5*y3-x3*y5)+(x3*y4-x4*y3));
                                        s1=0.5*Math.abs((pX3*pY2-pX2*pY3)+(pX2*y5-x5*pY2)+(x5*pY3-pX3*y5));
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        s1=Math.abs(s1);
                                        s2=Math.abs(s2);
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                }
                                else if(wrongPiont==1) {
//                                    System.out.println("1");
                                    if(wrongPiont1==1) {
                                        //px3 x3 x4
//                                        System.out.println(pX3+" "+pY3);
                                        S=0.5*Math.abs(x4*y5+x5*y3+x3*y4-x4*y3-x5*y4-x3*y5);
                                        s1=0.5*Math.abs(x4*pY3+pX3*y3+x3*y4-x4*y3-pX3*y4-x3*pY3);  
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                    if(wrongPiont2==1) {
//                                        System.out.println(pX2+" "+pY2);
                                        S=0.5*Math.abs(x4*y5+x5*y3+x3*y4-x4*y3-x5*y4-x3*y5);
                                        s1=0.5*Math.abs(x4*pY2+pX2*y3+x3*y4-x4*y3-pX2*y4-x3*pY2);   //px2 x4 x3
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        s1=Math.abs(s1);
                                        s2=Math.abs(s2);
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                    if(wrongPiont3==1) {
//                                        System.out.println(pX1+" "+pY1);
                                        S=0.5*Math.abs(x4*y5+x5*y3+x3*y4-x4*y3-x5*y4-x3*y5);
                                        s1=0.5*Math.abs((pX1*y5-x5*pY1)+(x5*y4-x4*y5)+(x4*pY1-pX1*y4));
                                        s2=S-s1;
                                        if(Math.abs(s2)>Math.abs(s1)) {
                                            temp=s2;
                                            s2=s1;
                                            s1=temp;
                                        }
                                        s1=Math.abs(s1);
                                        s2=Math.abs(s2);
                                        System.out.print((double)Math.round(s2*1000000)/1000000+" "+(double)Math.round(s1*1000000)/1000000);
                                    }
                                }
                            }
                        }
                        }
                        if(wrongPiont==2) {
                            System.out.print("The point is on the edge of the triangle");  //*
                        }
                    }
                    else {
                        System.out.println("data error");
                    }
                }
            }
            else {
                System.out.println("Wrong Format");
            }
        }
        else {
            if(allBlank<4) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
            else if(allBlank>4) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                numFive=cutArr();
                numSix=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour) && checkNum(numFive) && checkNum(numSix)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
        }
    }
    
    //case 5
    public void outWeather() {
        if(numData(numBlank())) {
            numOne=cutArr();
            numTwo=cutArr();
            numThree=cutArr();
            numFour=cutArr();
            if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour)) {
                x1=cutX(numOne);
                y1=cutY(numOne);
                x2=cutX(numTwo);
                y2=cutY(numTwo);
                x3=cutX(numThree);
                y3=cutY(numThree);
                x4=cutX(numFour);
                y4=cutY(numFour);
        
            
                    l1=Math.sqrt(Math.pow(x2-x3,2)+Math.pow(y2-y3,2));
                    l2=Math.sqrt(Math.pow(x3-x4,2)+Math.pow(y3-y4,2));
                    l3=Math.sqrt(Math.pow(x2-x4,2)+Math.pow(y2-y4,2));
                    L1=l1*l1;
                    L2=l2*l2;
                    L3=l3*l3;
                    if(traWeather()) {
                        S=0.5*Math.abs(x4*y2+x2*y3+x3*y4-x4*y3-x2*y4-x3*y2);
                        s1=0.5*Math.abs(x1*y2+x2*y3+x3*y1-x1*y3-x2*y1-x3*y2);  
                        s2=0.5*Math.abs(x1*y4+x4*y3+x3*y1-x1*y3-x4*y1-x3*y4);
                        s3=0.5*Math.abs(x1*y2+x2*y4+x4*y1-x1*y4-x2*y1-x4*y2);
                        if(s1==0 || s2==0 || s3==0) {
                            System.out.println("on the triangle");
                        }
                        else if(S==s1+s2+s3) {
                            System.out.println("in the triangle");
                        }
                        else {
                            System.out.println("outof the triangle");
                        }
                    }
                    else {
                        System.out.println("data error");
                    }
                
            }
            else {
                System.out.println("Wrong Format");
            }
        }
        else {
            if(allBlank<4) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
            else if(allBlank>4) {
                numOne=cutArr();
                numTwo=cutArr();
                numThree=cutArr();
                numFour=cutArr();
                numFive=cutArr();
                if(checkNum(numOne) && checkNum(numTwo) && checkNum(numThree) && checkNum(numFour) && checkNum(numFive)) {
                    System.out.println("wrong number of points");
                }
                else {
                    System.out.println("Wrong Format");
                }
            }
        }
    }
}

 

PTA题目集5 7-5ATM机类结构设计（一）

这道题我的构想是创建4个类分别储存4个人的银行账户信息，但后期我发现这样做并不合理。因为一家银行会有很多客户，也就意味着如果建类的话，需要建很多各类，这显然不太现实，所以我有了一种新的想法

类图：

 

代码：

 

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Scanner in = new Scanner(System.in);
        String cardNum;
        String passWord;
        String whatAtm;
        String money;
        
        int k=0;
        int i=0;

        check A = new check();
        
        String numArray=in.nextLine();
        while(numArray.compareTo("#")!=0) {
            String regexFive = "\\d{19}\\s{1,}\\d{8}\\s{1,}\\d{2}\\s{1,}-?([1-9]\\d*[.]\\d*|0\\[.]\\d*[1-9]\\d*)";
            String regexSix = "\\d{19}";
            boolean boolFive = numArray.matches(regexFive);
            boolean boolSix = numArray.matches(regexSix);
            if(boolSix && !boolFive) {
                A.checkMoney(numArray);
            }
            else if(boolFive) {
                cardNum=numArray.substring(0,19);
                k=A.cutNum(numArray,i+19);
                passWord=numArray.substring(k+1,k+9);
                k=A.cutNum(numArray,k+1+8);
                whatAtm=numArray.substring(k+1,k+3);
                k=A.cutNum(numArray,k+1+2);
                money=numArray.substring(k+1,numArray.length());
                A.checkCard(cardNum,passWord,whatAtm,money);
            }
            else {
                break;
            }
            numArray=in.nextLine();
        }
        
        A.outPut();
    }
}

class check {

    int p=0;
    String[] num = new String[40];
    
    Yang yang = new Yang();
    Guo guo = new Guo();
    Zhang zhang = new Zhang();
    Wei wei = new Wei();

    double moneyTake = 0;
    double amount = 0;

    public void checkCard(String numOne, String numTwo, String numThree, String numFour) {
        if (numOne.compareTo(yang.cardOne1) == 0 || numOne.compareTo(yang.cardOne2) == 0 || numOne.compareTo(yang.cardTwo1) == 0) {
            if (numTwo.compareTo("88888888") == 0) {
                if (numThree.compareTo("01") == 0 || numThree.compareTo("02") == 0 || numThree.compareTo("03") == 0 || numThree.compareTo("04") == 0) {
                    moneyTake = Double.parseDouble(numFour);
                    
                    if(numOne.compareTo(yang.cardOne1) == 0 || numOne.compareTo(yang.cardOne2) == 0) {
                        amount = yang.balanceCone1;
                        if (moneyTake > 0 && Math.abs(moneyTake) > amount) {
                            num[p]="Sorry,your account balance is insufficient.";
                            p++;
                        } else {
                            yang.balanceCone1 = amount - moneyTake;
                            if(moneyTake>0) {
                                num[p]="杨过在中国建设银行的"+numThree+"号ATM机上取款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",yang.balanceCone1);
                                p++;
                            }
                            if(moneyTake<0) {
                                numFour=numFour.substring(1,numFour.length());
                                num[p]="杨过在中国建设银行的"+numThree+"号ATM机上存款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",yang.balanceCone1);
                                p++;
                            }
                        }
                    }
                    else if(numOne.compareTo(yang.cardTwo1) == 0) {
                        amount = yang.balanceCone2;
                        if (moneyTake > 0 && Math.abs(moneyTake) > amount) {
                            num[p]="Sorry,your account balance is insufficient.";
                            p++;
                        } else {
                            yang.balanceCone2 = amount - moneyTake;
                            if(moneyTake>0) {
                                num[p]="杨过在中国建设银行的"+numThree+"号ATM机上取款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",yang.balanceCone2);
                                p++;
                            }
                            if(moneyTake<0) {
                                numFour=numFour.substring(1,numFour.length());
                                num[p]="杨过在中国建设银行的"+numThree+"号ATM机上存款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",yang.balanceCone2);
                                p++;
                            }
                        }
                    }
                } else if (numThree.compareTo("05") == 0 || numThree.compareTo("06") == 0) {
                    num[p]="Sorry,cross-bank withdrawal is not supported.";
                    p++;
                } else {
                    num[p]="Sorry,the ATM's id is wrong.";
                    p++;
                }
            } else {
                num[p]="Sorry,your password is wrong.";
                p++;
            }
        }
        else if (numOne.compareTo(guo.cardOne1) == 0) {
            if (numTwo.compareTo("88888888") == 0) {
                if (numThree.compareTo("01") == 0 || numThree.compareTo("02") == 0 || numThree.compareTo("03") == 0 || numThree.compareTo("04") == 0) {
                    moneyTake = Double.parseDouble(numFour);
                    amount = guo.balanceCone1;
                    if (moneyTake > 0 && Math.abs(moneyTake) > amount) {
                        num[p]="Sorry,your account balance is insufficient.";
                        p++;
                    } else {
                        guo.balanceCone1 = amount - moneyTake;
                        if(moneyTake>0) {
                            num[p]="郭靖在中国建设银行的"+numThree+"号ATM机上取款¥"+numFour;
                            p++;
                            num[p]="当前余额为¥"+String.format("%.2f",guo.balanceCone1);
                            p++;
                        }
                        if(moneyTake<0) {
                            numFour=numFour.substring(1,numFour.length());
                            num[p]="郭靖在中国建设银行的"+numThree+"号ATM机上存款¥"+numFour;
                            p++;
                            num[p]="当前余额为¥"+String.format("%.2f",guo.balanceCone1);
                            p++;
                        }
                    }
                } else if (numThree.compareTo("05") == 0 || numThree.compareTo("06") == 0) {
                    num[p]="Sorry,cross-bank withdrawal is not supported.";
                    p++;
                } else {
                    num[p]="Sorry,the ATM's id is wrong.";
                    p++;
                }
            } else {
                num[p]="Sorry,your password is wrong.";
                p++;
            }
        }

        else if (numOne.compareTo(zhang.cardOne1) == 0 || numOne.compareTo(zhang.cardTwo1) == 0 || numOne.compareTo(zhang.cardThree1) == 0 || numOne.compareTo(zhang.cardThree2) == 0) {
            if (numTwo.compareTo("88888888") == 0) {
                if (numThree.compareTo("05") == 0 || numThree.compareTo("06") == 0) {
                    moneyTake = Double.parseDouble(numFour);

                    if(numOne.compareTo(zhang.cardOne1)==0) {
                        amount = zhang.balance1;
                        if (moneyTake > 0 && Math.abs(moneyTake) > amount) {
                            num[p]="Sorry,your account balance is insufficient.";
                            p++;
                        } else {
                            zhang.balance1 = amount - moneyTake;
                            if(moneyTake>0) {
                                num[p]="张无忌在中国工商银行的"+numThree+"号ATM机上取款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",zhang.balance1);
                                p++;
                            }
                            if(moneyTake<0) {
                                numFour=numFour.substring(1,numFour.length());
                                num[p]="张无忌在中国工商银行的"+numThree+"号ATM机上存款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",zhang.balance1);
                                p++;
                            }
                        }
                    }
                    else if(numOne.compareTo(zhang.cardTwo1)==0) {
                        amount = zhang.balance2;
                        if (moneyTake > 0 && Math.abs(moneyTake) > amount) {
                            num[p]="Sorry,your account balance is insufficient.";
                            p++;
                        } else {
                            zhang.balance2 = amount - moneyTake;
                            if(moneyTake>0) {
                                num[p]="张无忌在中国工商银行的"+numThree+"号ATM机上取款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",zhang.balance2);
                                p++;
                            }
                            if(moneyTake<0) {
                                numFour=numFour.substring(1,numFour.length());
                                num[p]="张无忌在中国工商银行的"+numThree+"号ATM机上存款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",zhang.balance2);
                                p++;
                            }
                        }
                    }
                    else if(numOne.compareTo(zhang.cardThree1)==0 || numOne.compareTo(zhang.cardThree2)==0) {
                        amount = zhang.balance3;
                        if (moneyTake > 0 && Math.abs(moneyTake) > amount) {
                            num[p]="Sorry,your account balance is insufficient.";
                            p++;
                        } else {
                            zhang.balance3 = amount - moneyTake;
                            if(moneyTake>0) {
                                num[p]="张无忌在中国工商银行的"+numThree+"号ATM机上取款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",zhang.balance3);
                                p++;
                            }
                            if(moneyTake<0) {
                                numFour=numFour.substring(1,numFour.length());
                                num[p]="张无忌在中国工商银行的"+numThree+"号ATM机上存款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",zhang.balance3);
                                p++;
                            }
                        }
                    }
                } else if (numThree.compareTo("01") == 0 || numThree.compareTo("02") == 0 || numThree.compareTo("03") == 0 || numThree.compareTo("04") == 0) {
                    num[p]="Sorry,cross-bank withdrawal is not supported.";
                    p++;
                } else {
                    num[p]="Sorry,the ATM's id is wrong.";
                    p++;
                }
            } else {
                num[p]="Sorry,your password is wrong.";
                p++;
            }
        }
        else if (numOne.compareTo(wei.cardOne1) == 0 || numOne.compareTo(wei.cardTwo1) == 0) {
            if (numTwo.compareTo("88888888") == 0) {
                if (numThree.compareTo("05") == 0 || numThree.compareTo("06") == 0) {
                    
                    moneyTake = Double.parseDouble(numFour);
                    //case 1
                    if(numOne.compareTo(wei.cardOne1) == 0) {
                        amount = wei.balanceCone1;
                        if (moneyTake > 0 && Math.abs(moneyTake) > amount) {
                            num[p]="Sorry,your account balance is insufficient.";
                            p++;
                        } else {
                            wei.balanceCone1 = amount - moneyTake;
                            if(moneyTake>0) {
                                num[p]="韦小宝在中国工商银行的"+numThree+"号ATM机上取款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",wei.balanceCone1);
                                p++;
                            }
                            if(moneyTake<0) {
                                numFour=numFour.substring(1,numFour.length());
                                num[p]="韦小宝在中国工商银行的"+numThree+"号ATM机上存款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",wei.balanceCone1);
                                p++;
                            }
                        }
                    }
                    //case 2
                    else if(numOne.compareTo(wei.cardTwo1) == 0) {
                        amount = wei.balanceCone2;
                        if (moneyTake > 0 && Math.abs(moneyTake) > amount) {
                            num[p]="Sorry,your account balance is insufficient.";
                            p++;
                        } else {
                            wei.balanceCone2 = amount - moneyTake;
                            if(moneyTake>0) {
                                num[p]="韦小宝在中国工商银行的"+numThree+"号ATM机上取款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",wei.balanceCone2);
                                p++;
                            }
                            if(moneyTake<0) {
                                numFour=numFour.substring(1,numFour.length());
                                num[p]="韦小宝在中国工商银行的"+numThree+"号ATM机上存款¥"+numFour;
                                p++;
                                num[p]="当前余额为¥"+String.format("%.2f",wei.balanceCone2);
                                p++;
                            }
                        }
                    }
                } else if (numThree.compareTo("01") == 0 || numThree.compareTo("02") == 0 || numThree.compareTo("03") == 0 || numThree.compareTo("04") == 0) {
                    num[p]="Sorry,cross-bank withdrawal is not supported.";
                    p++;
                } else {
                    num[p]="Sorry,the ATM's id is wrong.";
                    p++;
                }
            } else {
                num[p]="Sorry,your password is wrong.";
                p++;
            }
        }
        else {
            num[p]="Sorry,this card does not exist.";
            p++;
        }
    }
    
    public void checkMoney(String num1) {
        if(num1.compareTo(yang.cardOne1)==0 || num1.compareTo(yang.cardOne2)==0) {
            num[p]="¥"+String.format("%.2f",yang.balanceCone1);
            p++;
        }
        else if(num1.compareTo(yang.cardTwo1)==0) {
            num[p]="¥"+String.format("%.2f",yang.balanceCone2);
            p++;
        }
        else if(num1.compareTo(zhang.cardOne1)==0) {
            num[p]="¥"+String.format("%.2f",zhang.balance1);
            p++;
        }
        else if(num1.compareTo(zhang.cardTwo1)==0) {
            num[p]="¥"+String.format("%.2f",zhang.balance2);
            p++;
        }
        else if(num1.compareTo(zhang.cardThree1)==0 || num1.compareTo(zhang.cardThree2)==0) {
            num[p]="¥"+String.format("%.2f",zhang.balance3);
            p++;
        }
        else if(num1.compareTo(guo.cardOne1)==0) {
            num[p]="¥"+String.format("%.2f",guo.balanceCone1);
            p++;
        }
        else if(num1.compareTo(wei.cardOne1)==0 || num1.compareTo(wei.cardTwo1)==0) {
            num[p]="¥"+String.format("%.2f",wei.balanceCone1);
            p++;
        }
    }

    public int cutNum(String num,int i) {
        int k=0;
        for(;i<num.length();i++) {
            if(num.charAt(i)==' ' && ((num.charAt(i+1)>=48 && num.charAt(i+1)<=57) || (num.charAt(i+1)=='-' || num.charAt(i+1)=='+'))) {
                k=i;
                return k;
            }
        }
        return 0;
    }
    
    public void outPut() {;
        for(int j=0;j<p;j++) {
            System.out.println(num[j]);
        }
    }
}

class Yang {
    String accountOne="3217000010041315709";
    String accountTwo="3217000010041315715";
    String cardOne1="6217000010041315709";
    String cardOne2="6217000010041315715";
    String cardTwo1="6217000010041315718";
    double balanceCone1=10000;
    double balanceCone2=10000;
}

class Guo {
    String accountOne="3217000010051320007";
    String cardOne1="6217000010051320007";
    double balanceCone1=10000;
}

class Zhang {
    String accountOne="3217000010041315709";
    String accountTwo="3217000010041315715";
    String cardOne1="6222081502001312389";
    String cardTwo1="6222081502001312390";
    String cardThree1="6222081502001312399";
    String cardThree2="6222081502001312400";
    double balance1=10000;
    double balance2=10000;
    double balance3=10000;
}

class Wei {
    String accountOne="3222081502051320785";
    String accountTwo="3222081502051320786";
    String cardOne1="6222081502051320785";
    String cardTwo1="6222081502051320786";
    double balanceCone1=10000;
    double balanceCone2=10000;
}

 

 

 

PTA题目集6 7-2 点线形系列4-凸四边形的计算

上文提到过这道题我最开始的想法是创建4个类去储存线段信息，但大量的getter和setter充斥在程序中，所以我有将getter和setter删除了。

4个线段类也显得有些冗余，所以我也将其删除了，只留下5个选项类，用于判断题目给的5个选项。下面我来讲述一些我遇到的难点。

1.凸凹四边形的判断  最开始我试图用cos去计算，但过长的代码，以及不完善的逻辑让我被迫放弃，最后选择了百度的公式去判断凸凹性。

2.判断是否为4变形  判断四边形是否成立比判断三角形是否成立的难度大写一些，首相判断是否有重合的点，三点共线的情况；接着两两相连计算每条线段的长度；最关键的一部在于判断有否有交叉的情况存在。计算第二条线段和第四条线段，第一条线段和第三条线段的交点是否在两线段内，若在则交叉，不在则不交叉。

3.4个点可以构成三角形或四边形  这个选项允许有一个点重合，或三点一线存在。有一个点重合，判断是否能构成三角线，三点一线成立，且四点一线不成立可以构成三角形。无点重合判断是否构成三角形。

4.判断点是否在三角形/四边形内部  这个选项有两种方法可以判断，用面积法或射线法，两种方法上午均有介绍，就不多做赘述了。

类图：

 

代码：

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        choose Choose = new choose();
        Choose.option();
    }
}

class choose {
    Scanner in = new Scanner(System.in);
    String arr;  //输入的字符串
    String cutArr;  //坐标
    String head;  //字符串前缀
    String mark;  //英文冒号
    String choice;  //选项
    String[] num;

    int wrong=0;
    int Choice=0; 
    int passport=0;
    double S=0,C=0;
    double l1_2=0, l2_3=0, l3_4=0, l4_1=0;
    double s1=0, s2=0, s3=0, s4=0;
    double px1=0, py1=0, px2=0, py2=0, px=0, py=0;
    double x1=0, y1=0, x2=0, y2=0, x3=0, y3=0, x4=0, y4=0;
    
    public void option() {
        inPut();
        if(arr.length()==1) {
            System.out.println("Wrong Format");
            wrong++;
        }
        else {
            cutHead();
            cutOption();
            if(arr.charAt(0)==' ') {
                System.out.println("Wrong Format");
                wrong++;
            }
        }
        if((wrong==0) && (choice.charAt(0)=='1' || choice.charAt(0)=='2' || choice.charAt(0)=='3' || choice.charAt(0)=='4' || choice.charAt(0)=='5')) {
            Choice=Integer.parseInt(choice);
        }
        else {
            System.out.println("Wrong Format");
            wrong++;
        }
        if(wrong==0) {
            switch(Choice) {
                case 1:
                    boolean resultOne=false;
                    boolean resultTwo=false;
                    squareCase();
                    if(passport==0) {
                        if(square()) {
                            resultOne=true;
                            if(parWeather()) {
                                resultTwo=false;
                            }
                        }
                        System.out.println(resultOne+" "+resultTwo);
                    }                
                    break;
                case 2:
                    boolean result1=false;
                    boolean result2=false;
                    boolean result3=false;
                    squareCase();
                    if(passport==0) {
                        if(!sameLine(x1,y1,x2,y2,x3,y3) || !sameLine(x2,y2,x1,y1,x4,y4) || !sameLine(x2,y2,x3,y3,x4,y4) || !sameLine(x1,y1,x3,y3,x4,y4)) {
                            if(equalLine()) {
                                result1=true;
                                if(chooseOne()) {
                                    result3=true;
                                    result2=true;
                                    
                                }
                            }
                            System.out.println(result1+" "+result2+" "+result3);
                            
//                            if(chooseTwo()) {
//                                result2=true;
//                            }
                        }
                        else {
                            System.out.println("not a quadrilateral");
                        }
                    }
                    break;
                case 3:
                    squareCase();
                    conOrnot();
                    boolean r=false;
                    if(!sameLine(x1,y1,x2,y2,x3,y3) || !sameLine(x2,y2,x1,y1,x4,y4) || !sameLine(x2,y2,x3,y3,x4,y4) || !sameLine(x1,y1,x3,y3,x4,y4)) {
                        passport++;
                        System.out.println("not a quadrilateral");
                    }
                    if(passport==0) {
                        if(conOrnot()) {
                            r=true;
                            C=l1_2+l2_3+l3_4+l4_1;
                            S=cauSone();
                        }
                        else {
                            C=l1_2+l2_3+l3_4+l4_1;
                            S=cauStwo();
                        }
                        System.out.print(r+" "+(double)Math.round(C*1000)/1000+" "+(double)Math.round(S*1000)/1000);
                    }
                    break;
                case 4:
                    System.out.println("not a quadrilateral or triangle");              
                    break;
                case 5:
                    squareCase();
                    if(inPiont()) {
                        System.out.println("in the quadrilateral");
                    }
                    else {
                        System.out.println("outof the quadrilateral");
                    }
                    squareCase();    
            }
        }
    }
    //输入字符串
    public void inPut() {
        arr=in.nextLine();
    }
    //切去头部
    public void cutHead() {
        head=arr.substring(0,2);
        arr=arr.substring(2,arr.length());
    }
    //提取选项与符号
    public void cutOption() {
        choice=head.substring(0,1);
        mark=head.substring(1,2);
    }
    //计算空格的个数
    public int numBlank() {
        int allBlank=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==' ') {
            allBlank++;
            }
        }
    return allBlank;
    }
    //判断输入数据是多于所需数据
    public boolean numData(int n) {
        switch(Choice) {
            case 1:
                if(n!=3) {
                    return false;
                }
                else {
                    return true;
                }
            case 2:
                if(n!=3) {
                    return false;
                }
                else {
                    return true;
                }
            case 3:
                if(n!=3) {
                    return false;
                }
                else {
                    return true;
                }
            case 4:
                if(n!=5) {
                    return false;
                }
                else {
                    return true;
                }    
            case 5:
                if(n!=4) {
                    return false;
                }
                else {
                    return true;
                }
        }
        return false;
    }
    //切割得x的值
    public double cutX(String arr) {
        String X;
        double x=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==',') {
                X=arr.substring(0,i);
                x=Double.parseDouble(X);
                break;
                }
            }
        return x;
    }
    public double cutY(String arr) {  //切割得y的值
        String Y;
        double y=0;
        for(int i=0;i<arr.length();i++) {
            if(arr.charAt(i)==',') {
                Y=arr.substring(i+1,arr.length());
                y=Double.parseDouble(Y);
                break;
            }
        }
        return y;
    }
    public boolean checkNum(String num) {  //检查格式是否错误
        String reagex="((-?([1-9]\\d*[.]\\d*|0\\[.]\\d*[1-9]\\d*))|-?[1-9]\\d*|0),((-?([1-9]\\d*[.]\\d*|0\\[.]\\d*[1-9]\\d*))|-?[1-9]\\d*|0)";
        boolean bool =num.matches(reagex);
        if(bool) {
            return true;
        }
        else {
            return false;
        }
    }
    //是否有三点一线
    public boolean sameLine(double X1,double Y1,double X2,double Y2,double X3,double Y3) {
        double k2=0;
        double K2=0;
        double b2=0;
        if(X1==X2 && X2==X3) {
            return false;
        }
        else if(X1!=X2 && X2==X3){
            return true;
        }
        else if(X1==X2 && X2!=X3) {
            return true;
        }
        else {
            k2=(Y3-Y2)/(X3-X2);   
            K2=(Y2-Y1)/(X2-X1);
            if(k2==K2) {
                return false;
            }
            else {
                return true;
            }
        }
    }    
    //有无点重合
    public boolean samePiont(double X1,double Y1,double X2,double Y2,double X3,double Y3,double X4,double Y4) {
        if(X1==X2 && Y1==Y2) {
            return true;
        }
        else if(X1==X3 && Y1==Y3) {
            return true;
        }
        else if(X1==X4 && Y1==Y4) {
            return true;
        }
        else if(X2==X3 && Y2==Y3) {
            return true;
        }
        else if(X2==X4 && Y2==Y4) {
            return true;
        }
        else if(X3==X4 && Y3==Y4) {
            return true;
        }
        else {
            return false;
        }
    }
    public void squareCase() {
        if(numData(numBlank())) {
            num=arr.split("\\s");
            for(int i=0;i<num.length;i++) {
                if(!checkNum(num[i])) {
                    System.out.println("Wrong Format");
                    passport++;
                    break;
                }
            }
        }
        else {
            num=arr.split("\\s");
            int wrong=0;
            for(int i=0;i<num.length;i++) {
                if(!checkNum(num[i])) {
                    wrong++;
                }
            }
            if(wrong==0) {
                System.out.println("wrong number of points");
            }
            else {
                System.out.println("Wrong Format");
            }
            passport++;
        }
        if(passport==0 && (Choice==1 || Choice==2 || Choice==3)) {
            x1=cutX(num[0]); y1=cutY(num[0]);
            x2=cutX(num[1]); y2=cutY(num[1]);
            x3=cutX(num[2]); y3=cutY(num[2]);
            x4=cutX(num[3]); y4=cutY(num[3]);
            l1_2=Math.sqrt(Math.pow(x1-x2,2)+Math.pow(y1-y2,2));
            l2_3=Math.sqrt(Math.pow(x2-x3,2)+Math.pow(y2-y3,2));   
            l3_4=Math.sqrt(Math.pow(x3-x4,2)+Math.pow(y3-y4,2));
            l4_1=Math.sqrt(Math.pow(x4-x1,2)+Math.pow(y4-y1,2));
        }
        if(passport==0 && Choice==4) {
            px1=cutX(num[0]); py1=cutY(num[0]);
            px2=cutX(num[1]); py2=cutY(num[1]);
            x1=cutX(num[2]); y1=cutY(num[2]);
            x2=cutX(num[3]); y2=cutY(num[3]); 
            x3=cutX(num[4]); y3=cutY(num[4]);
            x4=cutX(num[5]); y4=cutY(num[5]);
            if(px1==px2 && py1==py2) {
                System.out.println("points coincide");
                passport++;
            }
        }
        if(passport==0 && Choice==5) {
            px=cutX(num[0]); py=cutY(num[0]);
            x1=cutX(num[1]); y1=cutY(num[1]);
            x2=cutX(num[2]); y2=cutY(num[2]);
            x3=cutX(num[3]); y3=cutY(num[3]);
            x4=cutX(num[4]); y4=cutY(num[4]);
            
        }
    }
    public boolean square() {
        int wrong=0;
        if(!sameLine(x1,y1,x2,y2,x3,y3) || !sameLine(x1,y1,x2,y2,x4,y4) || !sameLine(x1,y1,x3,y3,x4,y4) || !sameLine(x2,y2,x3,y3,x4,y4)) {
            wrong++;
        }
        if(wrong==0) {
            return true;
        }
        else {
            return false;
        }
    }
    public boolean parWeather() {
        if(l1_2==l3_4 && l2_3==l4_1) {
            return true;
        }
        else {
            return false;
        }
    }
    public boolean equalLine() {
        if(l1_2==l2_3 && l3_4==l2_3 && l3_4==l4_1) {  //判断菱形或正方形
            return true;
        }
        else {  //是否为矩形
            return false;
        }
    }
    public boolean chooseOne() {  //判断任意两条临边是否垂直
        if( (x2-x1)*(x3-x2)+(y2-y1)*(y3-y2)==0 && (x3-x2)*(x4-x3)+(y3-y2)*(y4-y3)==0 && (x4-x3)*(x4-x1)+(y4-y3)*(y4-y1)==0 && (x4-x1)*(x2-x1)+(y4-y1)*(y2-y1)==0) {
            return true;
        }
        else {
            System.out.println((x2-x1)*(x3-x2)+(y2-y1)*(y3-y2));
            System.out.println((x3-x2)*(x4-x3)+(y3-y2)*(y4-y3));
            System.out.println((x4-x3)*(x4-x1)+(y4-y3)*(y4-y1));
            System.out.println((x4-x1)*(x2-x1)+(y4-y1)*(y2-y1));
            return false;
        }
    }
//    public boolean chooseTwo() {
//        if(l1_2==l3_4 && l2_3==l4_1) {
//            if((x2-x2)*(line2.getX3()-line2.getX2()) + (line1.getY2()-line1.getY1())*(line2.getY3()-line2.getY2()) == 0) {
//                return true;
//            }
//            else {
//                return false;
//            }
//        }
//        else {
//            return false;
//        }
//    }
    public boolean conOrnot() {  //Case5
        double z1 = (x4-x1)*(y2-y1)-(y4-y1)*(x2-x1);
        double z2 = (x1-x2)*(y3-y2)-(y1-y2)*(x3-x2);
        double z3 = (x2-x3)*(y4-y3)-(y2-y3)*(x4-x3);
        double z4 = (x3-x4)*(y1-y4)-(y3-y4)*(x1-x4);
        if(z1*z2*z3*z4 > 0 && z1*z2>0 && z3*z4>0) {
            return true;
        }
        else {
            return false;
        }
    }
    public double cauSone() {
        s1=0.5*Math.abs((x3*y2-x2*y3)+(x2*y1-x1*y2)+(x1*y3-x3*y1));
        s2=0.5*Math.abs((x3*y4-x4*y3)+(x4*y1-x1*y4)+(x1*y3-x3*y1));
        S=s1+s2;
        return S;
    }
    public double cauStwo() {
        s1=0.5*Math.abs((x3*y2-x2*y3)+(x2*y1-x1*y2)+(x1*y3-x3*y1));
        s2=0.5*Math.abs((x3*y4-x4*y3)+(x4*y1-x1*y4)+(x1*y3-x3*y1));
        s3=0.5*Math.abs((x3*y2-x2*y3)+(x2*y4-x4*y2)+(x4*y3-x3*y4));
        s4=0.5*Math.abs((x4*y2-x2*y4)+(x2*y1-x1*y2)+(x1*y4-x4*y1));
        if(s1+s2>s3+s4) {
            S=s3+s4;
            return S;
        }
        else {
            S=s1+s2;
            return S;
        }
    }
    public boolean inPiont() {
        s1=0.5*Math.abs((x3*y2-x2*y3)+(x2*py-px*y2)+(px*y3-x3*py));
        s2=0.5*Math.abs((x3*py-px*y3)+(px*y4-x4*py)+(x4*y3-x3*y4));
        s3=0.5*Math.abs((px*y2-x2*py)+(x2*y1-x1*y2)+(x1*py-px*y1));
        s4=0.5*Math.abs((px*y4-x4*py)+(x4*y1-x1*y4)+(x1*py-px*y1));
        S=0.5*Math.abs((x3*y2-x2*y3)+(x2*y1-x1*y2)+(x1*y3-x3*y1))+0.5*Math.abs((x3*y4-x4*y3)+(x4*y1-x1*y4)+(x1*y3-x3*y1));
        if(s1+s2+s3+s4==S) {
            return true;
        }
        else {
            return false;
        }
    }
}

 

心得体会

我认为这个月的学习相比上个与上个月的更注重逻辑思维的训练，感觉自己在做题的时候总是盲目的键类，最终导致变量之间的关系混乱不堪。

所以在我看来，在每次编程之前，应当先仔细审题，构建起程序的大体框架，认真布局，逐个实现功能。所以当前最重要的是，还是对于题目的分析。程序大体完成后，经常由于逻辑问题，去猜测试点。可以这个月的PTA作业让我深刻感受到了一个好的构架的重要性。