题目集1~3的总结性Blog

前言：

　　　　题目集1：本次题目集所涉及的知识点大部分都是 java 的基本语法，难度较小，分数占比最高的最后一题也仅是逻辑略复杂一些，所以此次的题量较大，总体难度较小。

　　　　题目集2：本次题目集所涉及的知识点主要是对字符以及字符串的处理、解析和提取，难度也不大，分数占比最高的第二题所涉及的东西要更多一些，此次的题量小，总体难度较小。

　　　　题目集3：本次题目集所涉及的知识点主要是 java 类与对象的设计，以及类的重复使用等，三道题目由浅入深，从点到线再到三角形，难度逐渐增加，这次题目的难度较大，特别是后    两题关于线和三角形的计算较多，所涉及的数学知识也很多，要将数学知识转化为计算机所能识别的代码，这是一个难点，虽然这次题目集只有三道题，但是总的来说难度                                      大。

设计与分析：

              题目集2：

7-2 串口字符解析

RS232是串口常用的通信协议，在异步通信模式下，串口可以一次发送5~8位数据，收发双方之间没有数据发送时线路维持高电平，相当于接收方持续收到数据“1”（称为空闲位），发送方有数据发送时，会在有效数据（5~8位，具体位数由通信双方提前设置）前加上1位起始位“0”，在有效数据之后加上1位可选的奇偶校验位和1位结束位“1”。请编写程序，模拟串口接收处理程序，注：假定有效数据是8位，奇偶校验位采用奇校验。

import java.util.Scanner;

public class Main {    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = new String();
        int i=0,num=1,sum=0;
        char a='2';
        s = in.next();
        
        if(s.length()<11) {
            System.out.println("null data");
            num++;
        }
        else{
            for( ; i<s.length(); i++) {
                if(i+10<s.length()) {
                    if(s.charAt(i) == '0') {
                        for(int n=1; n<9; n++) 
                            if(s.charAt(i+n) == '1')
                                sum++;
                        if(sum%2 == 0)
                            a='1';
                        else
                            a='0';
                        if(a == s.charAt(i+9) &&s.charAt(i+10) == '1') {    
                            System.out.print(num+":");
                            for(int n=1; n<9; n++) {
                                
                                System.out.print(s.charAt(i+n));}
                            System.out.println();
                            
                            num++;
                        }
                        
                        else if(s.charAt(i+10) == '1') {
                            System.out.println(num+":parity check error");
                            
                            num++;
                        }
                        else {
                            System.out.println(num+":validate error");
                            
                            num++;
                        }
                        i+=10;
                    }
                }
            sum=0;
            }
        }
        if(num == 1) {
            System.out.println("null data");
        }
        in.close();
    }
}

 

       本次代码在设计时未使用类与对象的思想，这是一个大的缺点，当然也有学习 Java 这门课程的时间较短的原因，相信随着之后学习的深入，我会逐步改进自己的编程思想；这次代码未使用函数思想并且存在大量的 if-else 语句，这使得这次的代码可读性差，这一点是我在编写时未曾考虑到的，在学习的深入以及一些 java 编程题目练习之后我认识到这是一个很大的问题，当面临一个复杂的问题，代码量到达了几万，几十万，甚至上百万时，这个不良的习惯会导致编写变得非常困难，所以我在之后的题目练习中要逐步养成好的编程习惯；还有一个问题是我在解决这个问题时没有用到一些已有的类来对字符串进行分析，比如 String 类 等，这点以后要加强，避免代码可读性和复杂性过高。

7-3 String的格式判断与内容提取

学校学生学号格式定义如下：
2位年级号+2位学院号+2位班级号+2位序号，如19041103，
编写程序处理用全院学生学号连接起来的长字符串，学院编号为20，包括17、18、19、20四个年级，请从字符串中提取特定两个班级202017班、202061班同学的学号后四位输出，输出编号之间用空格分隔，不换行。
注意：需要排除非法输入。

import java.util.Scanner;

public class Main {    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = new String();
        s = in.nextLine();
        boolean a = true;
        if(s.length()%8 != 0)
            a=false;
        else {
            for(int i=0; i<s.length(); i++) {
                if(s.charAt(i)<'0'||s.charAt(i)>'9')
                    a=false;
            }
            for(int i=0; i<s.length(); i+=8) {
                if(s.charAt(i+2)!='2'||s.charAt(i+3)!='0')
                    a=false;
                if(s.charAt(i)!='1') {
                    if(s.charAt(i+1)!='7'&&s.charAt(i+1)!='8'&&s.charAt(i+1)!='9')
                        a=false;
                    }
                if(s.charAt(i)=='2'&&s.charAt(i+1)=='0')
                    a=true;
            }
        }
        if(a==true) {
            int num=1;
            for(int i=0; i<s.length(); i+=8) {
                if(s.charAt(i)=='2'||s.charAt(i+1)=='0')
                if((s.charAt(i+4)=='1'&&s.charAt(i+5)=='7')||(s.charAt(i+4)=='6'&&s.charAt(i+5)=='1'))
                    if(num==1) {
                        System.out.printf("%c%c%c%c",s.charAt(i+4),s.charAt(i+5),s.charAt(i+6),s.charAt(i+7));
                        num++;
                    }
                    else
                        System.out.printf(" %c%c%c%c",s.charAt(i+4),s.charAt(i+5),s.charAt(i+6),s.charAt(i+7));
            }
        }
        else
            System.out.print("Wrong Format");
        in.close();
    }
}

        这个题目应该将格式判断，内容提取，输出等步骤进行分离，增强代码的可读性；且因为这个题目是对学号字符串进行判断，所以可以使用已有的 String类 里的如 split() 等方法

来对输入字符串进行解析，提取；这个代码需要改进的地方还有很多，我还要学习的东西也还有很多。

              题目集3：

7-1 点线形系列1-计算两点之间的距离

输入连个点的坐标，计算两点之间的距离。

 

import java.util.Scanner;
import java.util.ArrayList;

public class Main {    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = new String();
        s = in.nextLine();
        
        Judge judge = new Judge();
        judge.Judge(s,2);
        
        int err = judge.judge();
        if(err == 1) {
            System.out.println("Wrong Format");
        }
        else if(err == 2) {
            System.out.println("wrong number of points");
        }
        else {
            Trans c = new Trans();
            c.Trans(s);
            ArrayList<Double> gather = c.trans();
            Count count = new Count();
            count.Count(gather, 0);
            double result = count.count();
            System.out.println(result);
        }
        
        in.close();
    }
}

class Judge{
    String s = new String();
    String standard = "^(-?\\+?(0|[1-9][0-9]*))(\\.[0-9]*[1-9])?[,](-?\\+?(0|[1-9][0-9]*))(\\.[0-9]*[1-9])?$";
    int n;//应有的坐标数
    
    void Judge(String s, int n) {
        this.s=s;
        this.n=n;
    }
    
    int judge() {
        int p = 0;
        String[] str =s.split(" ");
        
        if(judge1(str)!=0) {
            p=1;
        }
        
        else if(judge2(str)!=0) {
            p=2;
        }
        return p;
    }
    
    int judge1(String[] str) {
        int p = 0;
        for(int i=0; i<str.length; i++) {
            if(!str[i].matches(standard))
                p=1;
        }
        return p;
    }
    
    int getStringCount(String str, char key) {
        int count = 0;
        int index = str.indexOf(key);
        while (index != -1) {
            count++;
            str = str.substring(index + 1);
            index = str.indexOf(key);
        }
        return count;
    }
    
    int judge2(String[] str) {
        int p = 0;
        if(str.length != n)
            p=2;
        return p;
    }
}

class Trans{
    ArrayList<Double> gather = new ArrayList<>();
    Cpoint a = new Cpoint();
    String s;
    
    void Trans(String s) {
        this.s=s;
    }
//输入：字符串
//操作：转换为double并保存至链表gather
//输出：链表gather
    ArrayList<Double> trans() {
        int num = getStringCount(s, ',');
        String[] str =s.split(" ");

        for(int i=0; i<num; i++) {
        a.tran(str[i]);
        gather.add(a.x);
        gather.add(a.y);
        }
        
        return gather;
    }

    int getStringCount(String str, char key) {
        int count = 0;
        int index = str.indexOf(key);
        while (index != -1) {
            count++;
            str = str.substring(index + 1);
            index = str.indexOf(key);
        }
        return count;
    }
}

class Cpoint{
    double x;
    double y;
//输入：（x，y）
//操作：转换为double
//输出：x和y的double形式
    void tran(String s) {
        String[] str =s.split(",");
        
        x=transdouble(str[0]);
        
        y=transdouble(str[1]);
    }
    
    double transdouble(String s) {
        double num = 0;
        int index = s.indexOf('.');
        int overindex=-1;
        if(index>0) {
            for(int i=index-1; i>-1; i--) {
                if(s.charAt(i)<'0'||s.charAt(i)>'9') {
                    overindex=i;
                    break;
                }
                num+=(s.charAt(i)-'0')*Math.pow(10,index-i-1);
            }
        
            for(int i=index+1; i<s.length(); i++) {
                num+=(s.charAt(i)-'0')*Math.pow(10,index-i);
            }
        }
        else {
            for(int i=s.length()-1; i>-1; i--) {
                if(s.charAt(i)<'0'||s.charAt(i)>'9') {
                    overindex=i;
                    break;
                }
                num+=(s.charAt(i)-'0')*Math.pow(10,s.length()-1-i);
            }
        }
        
        if(overindex!=-1) {
            if(s.charAt(overindex) == '-')
                num=-num;
        }
        return num;
    }
}

class Count{
    ArrayList<Double> gather = new ArrayList<>();
    int operation;
    
    void Count(ArrayList<Double> gather,int operation){
        this.gather=gather;
        this.operation=operation;
    }
    
    double count() {
        double d=-1;
        switch(operation) {
        case 0: d = Math.sqrt((gather.get(2)-gather.get(0))*(gather.get(2)-gather.get(0))+(gather.get(3)-gather.get(1))*(gather.get(3)-gather.get(1)));
        }
            
        return d;
    }
}

 

       很显然，我将这个题目复杂化了，这是一个很差劲的代码。这次我初步运用了类与对象的概念，分别做了  判断  转换  点  三个类，这三个类所做的事情可以写在  点  这一个类里完成，且后两题完全可以以 点 作为最基本参数来进行操作，这让我认识到提前设计 类图 是一件多么重要的事情，能为我们理清思路，减少很多的坑。

7-2 点线形系列2-线的计算

用户输入一组选项和数据，进行与直线有关的计算。选项包括：
1：输入两点坐标，计算斜率，若线条垂直于X轴，输出"Slope does not exist"。
2：输入三个点坐标，输出第一个点与另外两点连线的垂直距离。
3：输入三个点坐标，判断三个点是否在一条线上，输出true或者false。
4：输入四个点坐标，判断前两个点所构成的直线与后两点构成的直线是否平行，输出true或者false.
5：输入四个点坐标，计算输出前两个点所构成的直线与后两点构成的直线的交点坐标，x、y坐标之间以英文分隔","，并输出交叉点是否在两条线段之内（不含四个端点）的判断结果(true/false)，判断结果与坐标之间以一个英文空格分隔。若两条线平行，没有交叉点，则输出"is parallel lines,have no intersection point"。

基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。
例如：1:0,0 1,1
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
不论哪个选项，如果格式、点数量都符合要求，但构成任一条线的两个点坐标重合，输出"points coincide"，

import java.util.Scanner;
import java.util.ArrayList;

public class Main {    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = new String();
        s = in.nextLine();

        Judge judge = new Judge();
        switch (s.charAt(0)) {
            case '1':;
            case '2':;
            case '3':{judge.Judge(s.substring(2),3);break;}
            case '4':{judge.Judge(s.substring(2),5);break;}
            case '5':{judge.Judge(s.substring(2),4);break;}
        }
        
        int err = judge.judge();
        if(s.charAt(1)!=':') err=1;
        if(err == 1) {
            System.out.println("Wrong Format");
        }
        else if(err == 2) {
            System.out.println("wrong number of points");
        }
        else {
            
            Trans c = new Trans();
            c.Trans(s.substring(2));
            double[][] gather = c.trans();
            
            Point a = new Point();
            a.Point(gather[gather.length-3][0],gather[gather.length-3][1]);
            Point b = new Point();
            b.Point(gather[gather.length-2][0],gather[gather.length-2][1]);
            Point d = new Point();
            d.Point(gather[gather.length-1][0],gather[gather.length-1][1]);
            Triangle triangle = new Triangle();
            boolean m=triangle.Triangle(a, b, d);
            Line line= new Line();
            boolean n=false;
            if(s.charAt(0)=='4') {
                Point e = new Point();
                e.Point(gather[0][0],gather[0][1]);
                Point f = new Point();
                f.Point(gather[1][0],gather[1][1]);
                n=line.Line(e, f);
                if(n)
                    System.out.println("points coincide");
            }
            if((line.Line(a, b)||line.Line(a, d)||line.Line(b, d)||!m)&&!n)
                System.out.println("data error");
            else if(!n)
                count(s.charAt(0),gather,triangle);

        }
        
        in.close();
    }
    
    static void count(char operation,double[][] gather,Triangle triangle) {
        switch(operation) {
            case '1':{
                    System.out.println(triangle.dengyao()+" "+triangle.dengbian());
                    break;}
            case '2':{
                    //System.out.printf("%f %f %f,%f");
                    System.out.println((float)(triangle.zhouchang()+0.0000005)+" "+(float)(triangle.mianji())+" "+(float)(triangle.zhongxin().x)+",");
                    System.out.print((float)(triangle.zhongxin().y+0.0000005));
                    break;}
            case '3':{
                    System.out.println((triangle.jiao()=='d')+" "+(triangle.jiao()=='z')+" "+(triangle.jiao()=='r'));
                    break;}
            case '4':{
                    Point a = new Point();
                    a.Point(gather[0][0],gather[0][1]);
                    Point b = new Point();
                    b.Point(gather[1][0],gather[1][1]);
                    Line n = new Line();
                    boolean m=n.Line(a,b);
                    if(!m)
                        triangle.jiaodianshu(n);
                    else
                        System.out.println("points coincide");
                    break;}
            case '5':{
                    
                    break;}
        }
    }
    
}

class Judge{
    String s = new String();
    String standard = "^(-?\\+?(0|[1-9][0-9]*))(\\.[0-9]*)?[,](-?\\+?(0|[1-9][0-9]*))(\\.[0-9]*)?$";
    int n;//应有的坐标数
    
    void Judge(String s, int n) {
        this.s=s;
        this.n=n;
    }
    
    int judge() {
        int p = 0;
        String[] str =s.split(" ");
        
        if(judge1(str)!=0) {
            p=1;
        }
        
        else if(judge2(str)!=0) {
            p=2;
        }
        
        return p;
    }
    
    int judge1(String[] str) {
        int p = 0;
        for(int i=0; i<str.length; i++) {
            if(!str[i].matches(standard)) {
                p=1;
                break;
            }
        }
        return p;
    }
    
    int judge2(String[] str) {
        int p = 0;
        if(str.length != n)
            p=2;
        return p;
    }

}

class Trans{
    ArrayList<Double> gather = new ArrayList<>();
    String s;
    double x;
    double y;
    int n;
    
    void Trans(String s) {
        this.s=s;
    }
//输入：字符串
//操作：转换为double并保存至链表gather
//输出：链表gather
    double[][] trans() {
        String[] str =s.split(" ");

        for(int i=0; i<str.length; i++) {
            tran(str[i]);
            gather.add(x);
            gather.add(y);
        }
        
        n=gather.size()/2;
        double[][] D = new double[n][2];
        for(int i=0; i<n; i++) {
            D[i][0]=gather.get(2*i);
            D[i][1]=gather.get(2*i+1);
        }
        return D;
    }
    
    void tran(String s) {
        String[] str =s.split(",");
        
        x=transdouble(str[0]);
        
        y=transdouble(str[1]);
    }
    
    double transdouble(String s) {
            double num = Double.parseDouble(s);

            return num;
        }
}

class Point{
    double x;
    double y;
    
    void Point(double x,double y) {
        this.x=x;
        this.y=y;
    }
    
    double juli(Point a) {
        return Math.sqrt((x-a.x)*(x-a.x)+(y-a.y)*(y-a.y));
    } 
    
}

class Line{
    Point a;
    Point b;
    double A;
    double B;
    double C;
    
    boolean Line(Point a, Point b) {
        this.a=a;
        this.b=b;
        A=b.y-a.y;
        B=a.x-b.x;
        C=(b.x*a.y-a.x*b.y);
        return (a.x==b.x&&a.y==b.y);
    }
    
    boolean chuizhi() {
        return (a.x==b.x);
    }
    
    double xielv() {
        if(((a.y-b.y)/(a.x-b.x))==-0.0)
            return 0;
        return ((a.y-b.y)/(a.x-b.x));
    }
    
    double juli(Point c) {
        if(a.x==b.x) {
            return Math.abs(c.x-a.x);
        }
        return Math.abs(A*c.x+B*c.y+C)/Math.sqrt(A*A+B*B);
    }
    
    boolean pingxing(Line c) {
        boolean px;
        Line ab = new Line();
        ab.Line(a, b);
        if((ab.chuizhi()&&c.chuizhi())||(ab.A==c.A&&ab.B==c.B&&ab.C==c.C))
            px=true;
        else
            px = (ab.xielv()==c.xielv());
        return px;
    }
    
    Point jiaodian(Line c) {
        Point e = new Point();
        e.x=(B*c.C-c.B*C)/(A*c.B-c.A*B);
        e.y=-(A*c.C-c.A*C)/(A*c.B-c.A*B);
        return e;
    }
    
    boolean nei(Point e) {
        boolean n=false;
        if((e.y>a.y&&e.y<b.y)||(e.y<a.y&&e.y>b.y))
            n=true;
        
        return n;
    }
}

       这个代码是在听了老师的课之后，明白了 面对对象编程 与面对过程编程 之间的一些区别，并且跟随老师学习了解决这三道题的设计 类 的基本思路之后写的。由于最初写第一题时就设计了  判断  转换  类，所以未再进行删减更改。相对于第一题，这里使用了正则表达式，并且对各类里的一些函数进行了改进，删减了一些不必要的内容，改善了一些逻辑方面的代码等。增加的  线  的类，在写  线这个类的时候我对类与类之间的关系有了一些了解，比如  线  的基本参数可以是两个点组成；  线  这个类的一些方法之间可以相互调用，避免重复编写，增加代码量，降低可读性。

7-3 点线形系列3-三角形的计算

用户输入一组选项和数据，进行与三角形有关的计算。选项包括：
1：输入三个点坐标，判断是否是等腰三角形、等边三角形，判断结果输出true/false，两个结果之间以一个英文空格符分隔。
2：输入三个点坐标，输出周长、面积、重心坐标，三个参数之间以一个英文空格分隔，坐标之间以英文","分隔。
3：输入三个点坐标，输出是钝角、直角还是锐角三角形，依次输出三个判断结果（true/false），以一个英文空格分隔，
4：输入五个点坐标，输出前两个点所在的直线与三个点所构成的三角形相交的交点数量，如果交点有两个，则按面积大小依次输出三角形被直线分割成两部分的面积。若直线与三角形一条线重合，输出"The point is on the edge of the triangle"
5：输入四个点坐标，输出第一个是否在后三个点所构成的三角形的内部（输出in the triangle/outof triangle）。
必须使用射线法，原理：由第一个点往任一方向做一射线，射线与三角形的边的交点（不含点本身）数量如果为1，则在三角形内部。如果交点有两个或0个，则在三角形之外。若点在三角形的某条边上，输出"on the triangle"

基本输出格式见每种选项的描述。
异常情况输出：
如果不符合基本格式，输出"Wrong Format"。
如果符合基本格式，但输入点的数量不符合要求，输出"wrong number of points"。
如果输入的三个点无法构成三角形，输出"data error"。
注意：输出的数据若小数点后超过6位，只保留小数点后6位，多余部分采用四舍五入规则进到最低位。小数点后若不足6位，按原始位数显示，不必补齐。例如：1/3的结果按格式输出为 0.333333，1.0按格式输出为1.0

选项4中所输入线的两个点坐标重合，输出"points coincide"，

import java.util.Scanner;
import java.util.ArrayList;

public class Main {    
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = new String();
        s = in.nextLine();

        Judge judge = new Judge();
        switch (s.charAt(0)) {
            case '1':;
            case '2':;
            case '3':{judge.Judge(s.substring(2),3);break;}
            case '4':{judge.Judge(s.substring(2),5);break;}
            case '5':{judge.Judge(s.substring(2),4);break;}
        }
        
        int err = judge.judge();
        if(s.charAt(1)!=':') err=1;
        if(err == 1) {
            System.out.println("Wrong Format");
        }
        else if(err == 2) {
            System.out.println("wrong number of points");
        }
        else {
            
            Trans c = new Trans();
            c.Trans(s.substring(2));
            double[][] gather = c.trans();
            
            Point a = new Point();
            a.Point(gather[gather.length-3][0],gather[gather.length-3][1]);
            Point b = new Point();
            b.Point(gather[gather.length-2][0],gather[gather.length-2][1]);
            Point d = new Point();
            d.Point(gather[gather.length-1][0],gather[gather.length-1][1]);
            Triangle triangle = new Triangle();
            boolean m=triangle.Triangle(a, b, d);
            Line line= new Line();
            boolean n=false;
            if(s.charAt(0)=='4') {
                Point e = new Point();
                e.Point(gather[0][0],gather[0][1]);
                Point f = new Point();
                f.Point(gather[1][0],gather[1][1]);
                n=line.Line(e, f);
                if(n)
                    System.out.println("points coincide");
            }
            if((line.Line(a, b)||line.Line(a, d)||line.Line(b, d)||!m)&&!n)
                System.out.println("data error");
            else if(!n)
                count(s.charAt(0),gather,triangle);

        }
        
        in.close();
    }
    
    static void count(char operation,double[][] gather,Triangle triangle) {
        switch(operation) {
            case '1':{
                    System.out.println(triangle.dengyao()+" "+triangle.dengbian());
                    break;}
            case '2':{
                    out(triangle.zhouchang());
                    System.out.print(" ");
                    out(triangle.mianji());
                    System.out.print(" ");
                    out(triangle.zhongxin().x);
                    System.out.print(",");
                    out(triangle.zhongxin().y);
                    
                    break;}
            case '3':{
                    System.out.println((triangle.jiao()=='d')+" "+(triangle.jiao()=='z')+" "+(triangle.jiao()=='r'));
                    break;}
            case '4':{
                    Point a = new Point();
                    a.Point(gather[0][0],gather[0][1]);
                    Point b = new Point();
                    b.Point(gather[1][0],gather[1][1]);
                    Line n = new Line();
                    boolean m=n.Line(a,b);
                    if(!m) {
                        if(triangle.jiaodianshu(n)!=-1)
                            System.out.println(triangle.jiaodianshu(n));
                        else
                            System.out.println("The point is on the edge of the triangle");
                    }
                    else
                        System.out.println("points coincide");
                    break;}
            case '5':{
                    Point a = new Point();
                    a.Point(gather[0][0],gather[0][1]);
                    Line y = new Line();
                    
                    if(triangle.neibu(a)) {
                        boolean o=true;
                        y.Line(triangle.a, triangle.b);
                        if(Math.abs(y.juli(a)-0)<0.000000001&&y.nei(a)) {
                            System.out.println("on the triangle");
                            o=false;
                        }
                        y.Line(triangle.a, triangle.c);
                        if(Math.abs(y.juli(a)-0)<0.000000001&&o&&y.nei(a)) {
                            System.out.println("on the triangle");
                            o=false;
                        }
                        y.Line(triangle.b, triangle.c);
                        if(Math.abs(y.juli(a)-0)<0.000000001&&o&&y.nei(a)) {
                            System.out.println("on the triangle");
                            o=false;
                        }
                        if(o)
                            System.out.println("in the triangle");
                    }
                    else
                        System.out.println("outof the triangle");
                    break;}
        }
    }
    
    static void out(double i) {
//    int d = (int)(i/0.0000001)-(int)(i/0.000001)*10;
    int e= (int)(i/0.000001)-(int)(i/0.00001)*10;
    if(e==0)
        System.out.print((float)i);
    else
        System.out.printf("%.6f",(float)i);
    }
}

class Judge{
    String s = new String();
    String standard = "^(-?\\+?(0|[1-9][0-9]*))(\\.[0-9]*)?[,](-?\\+?(0|[1-9][0-9]*))(\\.[0-9]*)?$";
    int n;//应有的坐标数
    
    void Judge(String s, int n) {
        this.s=s;
        this.n=n;
    }
    
    int judge() {
        int p = 0;
        String[] str =s.split(" ");
        
        if(judge1(str)!=0) {
            p=1;
        }
        
        else if(judge2(str)!=0) {
            p=2;
        }
        
        return p;
    }
    
    int judge1(String[] str) {
        int p = 0;
        for(int i=0; i<str.length; i++) {
            if(!str[i].matches(standard)) {
                p=1;
                break;
            }
        }
        return p;
    }
    
    int judge2(String[] str) {
        int p = 0;
        if(str.length != n)
            p=2;
        return p;
    }

}

class Trans{
    ArrayList<Double> gather = new ArrayList<>();
    String s;
    double x;
    double y;
    int n;
    
    void Trans(String s) {
        this.s=s;
    }
//输入：字符串
//操作：转换为double并保存至链表gather
//输出：链表gather
    double[][] trans() {
        String[] str =s.split(" ");

        for(int i=0; i<str.length; i++) {
            tran(str[i]);
            gather.add(x);
            gather.add(y);
        }
        
        n=gather.size()/2;
        double[][] D = new double[n][2];
        for(int i=0; i<n; i++) {
            D[i][0]=gather.get(2*i);
            D[i][1]=gather.get(2*i+1);
        }
        return D;
    }
    
    void tran(String s) {
        String[] str =s.split(",");
        
        x=transdouble(str[0]);
        
        y=transdouble(str[1]);
    }
    
    double transdouble(String s) {
            double num = Double.parseDouble(s);

            return num;
        }
}

class Point{
    double x;
    double y;
    
    void Point(double x,double y) {
        this.x=x;
        this.y=y;
    }
    
    double juli(Point a) {
        return Math.sqrt((x-a.x)*(x-a.x)+(y-a.y)*(y-a.y));
    } 
    
}

class Line{
    Point a;
    Point b;
    double A;
    double B;
    double C;
    
    boolean Line(Point a, Point b) {
        this.a=a;
        this.b=b;
        A=b.y-a.y;
        B=a.x-b.x;
        C=(b.x*a.y-a.x*b.y);
        return (a.x==b.x&&a.y==b.y);
    }
    
    boolean chuizhi() {
        return (a.x==b.x);
    }
    
    double xielv() {
        if(((a.y-b.y)/(a.x-b.x))==-0.0)
            return 0;
        return ((a.y-b.y)/(a.x-b.x));
    }
    
    double juli(Point c) {
        if(a.x==b.x) {
            return Math.abs(c.x-a.x);
        }
        return Math.abs(A*c.x+B*c.y+C)/Math.sqrt(A*A+B*B);
    }
    
    boolean pingxing(Line c) {
        boolean px;
        Line ab = new Line();
        ab.Line(a, b);
        if((ab.chuizhi()&&c.chuizhi())||(ab.A==c.A&&ab.B==c.B&&ab.C==c.C))
            px=true;
        else
            px = (ab.xielv()==c.xielv());
        return px;
    }
    
    Point jiaodian(Line c) {
        Point e = new Point();
        e.x=(B*c.C-c.B*C)/(A*c.B-c.A*B);
        e.y=-(A*c.C-c.A*C)/(A*c.B-c.A*B);
        return e;
    }
    
    boolean nei(Point e) {
        boolean n=false;
        if((e.y>a.y&&e.y<b.y)||(e.y<a.y&&e.y>b.y))
            n=true;
        if((e.x>a.x&&e.x<b.x)||(e.x<a.x&&e.x>b.x))
            n=true;
        return n;
    }
}

class Triangle{
    Point a;
    Point b;
    Point c;
    
    boolean Triangle(Point a,Point b,Point c) {
        this.a=a;
        this.b=b;
        this.c=c;
        boolean m = true;
        if(a.juli(b)>=(a.juli(c)+b.juli(c)))
            m=false;
        else if(a.juli(c)>=(a.juli(b)+b.juli(c)))
            m=false;
        else if(b.juli(c)>=(a.juli(b)+a.juli(c)))
            m=false;
        return m;
    }
    
    boolean dengyao() {
        if((a.juli(b)==a.juli(c))||(a.juli(b)==b.juli(c))||(a.juli(c)==b.juli(c)))
            return true;
        else
            return false;
    }
    
    boolean dengbian() {
        if(a.juli(b)==a.juli(c)&&a.juli(b)==b.juli(c))
            return true;
        else
            return false;
    }
    
    double zhouchang() {
        return (a.juli(b)+a.juli(c)+b.juli(c));
    }
    
    double mianji() {
        double p=zhouchang()/2;
        return (Math.sqrt(p*(p-a.juli(b))*(p-a.juli(c))*(p-b.juli(c))));
    }
    
    Point zhongxin() {
        Point m = new Point();
        m.x=(a.x+b.x+c.x)/3.0;
        m.y=(a.y+b.y+c.y)/3.0;
        return m;
    }
    
    char jiao() {
        char m='r';
        
        if(a.juli(b)*a.juli(b)+b.juli(c)*b.juli(c)<a.juli(c)*a.juli(c))
            m='d';
        else if(a.juli(c)*a.juli(c)+b.juli(c)*b.juli(c)<a.juli(b)*a.juli(b))
            m='d';
        else if(a.juli(b)*a.juli(b)+a.juli(c)*a.juli(c)<b.juli(c)*b.juli(c))
            m='d';
        if(Math.abs(a.juli(b)*a.juli(b)+b.juli(c)*b.juli(c)-a.juli(c)*a.juli(c))<0.000000001)
            m='z';
        else if(Math.abs(a.juli(c)*a.juli(c)+b.juli(c)*b.juli(c))-a.juli(b)*a.juli(b)<0.000000001)
            m='z';
        else if(Math.abs(a.juli(b)*a.juli(b)+a.juli(c)*a.juli(c)-b.juli(c)*b.juli(c))<0.000000001)
            m='z';
        
        return m;
    }
    
    int jiaodianshu(Line n) {
        int m=0;
        Line q = new Line();
        if(!q.Line(a, b)) {
            if(n.juli(a)==0&&n.juli(b)==0)
                return -1;
            if(q.nei(q.jiaodian(n)))
                m+=1;
            if(n.juli(a)==0)
                m+=1;
        }
        if(!q.Line(a, c)) {
            if(n.juli(a)==0&&n.juli(c)==0)
                return -1;
            if(q.nei(q.jiaodian(n)))
                m+=1;
            if(n.juli(b)==0)
                m+=1;
        }
        if(!q.Line(b, c)) {
            if(n.juli(c)==0&&n.juli(b)==0)
                return -1;
            if(q.nei(q.jiaodian(n)))
                m+=1;
            if(n.juli(c)==0)
                m+=1;
        }
        return m;
    }
    
    boolean neibu(Point g) {
        boolean h = false;
        double sum=0;
        Line q = new Line();
        q.Line(a, b);
        sum+=a.juli(b)*q.juli(g)/2;
        q.Line(a, c);
        sum+=a.juli(c)*q.juli(g)/2;
        q.Line(b, c);
        sum+=b.juli(c)*q.juli(g)/2;
        if(Math.abs(mianji()-sum)<0.0000000001)
            h=true;
        return h;
    }
    
}

       这题直至截止时间我也没有拿到满分，尤其是对于输出格式问题一直没有想到一个合适的方法来解决；选项4非输出格式错误的几个测试点和选项5的几个测试点也没有通过，很遗憾，我没能在规定的时间内解决这道题。从这道题里我也发现类与类之间有很多的关联，比如在这道题里就有不少的地方用到了  点  和  线  这两个类里的方法，求距离，求交点，这些都可以使用到已有的类方法。后两题使用到的数学方法较多，如何把我们学过的知识写成代码这是一件很有挑战性的事情，用等式来解决复杂的数学问题，将问题用逻辑一步一步的串联起来，这是解决这道题所需要的最基本的东西。在这道题上我也更加认识到了自身的不足，这个代码也还存在很多的问题。逻辑问题，书写问题，时间空间复杂度问题，这一个个的问题都要之后通过不断地学习，不断地练习来解决它们，我也相信我将来能够做到。

采坑心得：

       源码在提交过程中遇到过很多的问题，这里不一一赘述，其中我遇到的最大的问题反而是最小的问题，如同

1、题目集3 里的第二题的正则表达式

改前:

    String standard = "^(-?\\+?(0|[1-9][0-9]*))(\\.[0-9]*[1-9])?[,](-?\\+?(0|[1-9][0-9]*))(\\.[0-9]*[1-9])?$";

 

改后:

    String standard = "^(-?\\+?(0|[1-9][0-9]*))(\\.[0-9]*)?[,](-?\\+?(0|[1-9][0-9]*))(\\.[0-9]*)?$";

仅仅是小数点后能否零结尾导致我每一个选项都有1或2个点过不了，这个错误是极其不正常的，开始我认为是其他错误导致浪费了很多的时间，之后对正则表达式进行测试才发现了这个问题所在；在其他题中也出现过类似的问题，每一次都会花费大量的时间来解决它；所以我在以后的代码编写中要小心这种不易查找的”小问题“出现，尽可能做到细致。

2、还有在进行计算时使用的ArrayList链表，开始使用时总是有很多的不方便，特别是在获取数据进行计算时很不方便，之后添加

        n=gather.size()/2;
        double[][] D = new double[n][2];
        for(int i=0; i<n; i++) {
            D[i][0]=gather.get(2*i);
            D[i][1]=gather.get(2*i+1);
        }
        return D;
    }

将其转换为  double数组  来传参，在使用时就会方便许多，当然也是由于我能力还不够，运用ArrayList链表不熟练导致，但这确实让我之后思路更通畅了些。

3、最后，我在进行一些等值运算时发现浮点数与整形数的一些区别，在进行上网搜索之后我意识到

a.juli(b)*a.juli(b)+b.juli(c)*b.juli(c)==a.juli(c)*a.juli(c))

与

Math.abs(a.juli(b)*a.juli(b)+b.juli(c)*b.juli(c)-a.juli(c)*a.juli(c))<0.000000001

是不一样的，由于浮点数的特殊性，它的精度与我们日常认知存在出入，所以一般在进行浮点数运算时代码都会采用第二种比较方法，相减的绝对值小于一个极小数则认为它们相等，这一点在进行浮点数运算中极为重要，特别是需要使用到  相等  关系时更加要注意。

以上仅仅是我所遇到问题的一部分，但是却让我遇到了较大的坑，这是我这几次踩坑的一点点心得，我自身所存在的问题远不止这些，希望在之后不断地”踩坑“中能不断发现问题，不断解决问题，争取提升自我。

改进建议：

        题目集2的7-2、7-3可以用函数形式来表达；题目集3的7-1的类的设计不合理，可将格式检查、字符串转换、点这三个类合并，让代码更简洁明了；题目集3的7-2、7-3两题在设计类方法时传参时不妥，导致方法的重复使用增加了难度，因此我认为在设计方法时设计好传参对于函数重复使用是很重要的。然后就是编写代码的习惯并不好，这要在之后的练习中不断地改进，不断养成一个好的习惯，让代码逻辑性、可读性更佳。

总结：

       对于这三次题目集，我学到了 java 基本语法的使用，能够编写 java 程序并运行；学习了对字符及字符串的解析、提取等操作；并且对类与对象有了基本的概念，对面对对象编程也有了基本概念；此外对java与C语言不同的语句也有了更深的理解，处理如题目集3这种较为复杂的问题也学习了更好的思路；总的来说，对于刚接触java的我来说，这三次题目集让我对java有了一些最基本的了解，真正的开始学习java。我还需要改进的地方有很多，代码，逻辑，处理问题的方式等等，其中处理问题的方式是我在之后很长一段时间需要学习并掌握的；然后代码的规范性、变量和方法的命名合理性等等都要不断练习；在之后的练习中我可以通过类图等方式来理清基本逻辑再进行代码的编写，这是改进代码逻辑性的很好方式，我之后编写前要尽量画出类图，尤其是面对难题时更加有必要。对教师、课程、作业、实验、课上及课下组织方式等方面我没有什么意见和建议，有两点建议：1.上课之前希望老师能提前通知，因为有两次课都是突然通知导致我没能够及时进入课堂学习；2.上课时可以多讲一些具体的题目分析，比如pta发布的作业等，因为我个人感觉这对于学习新知识和巩固学过的知识是一个很好的方式，对于我们理解知识点也有一些帮助。