21201634-赵修培

前言

 

 对于初学Java的我，还不知道是因为习惯了上学期C语言面向过程思维，还是因为自己对于面向对象思维的不深入，导致自己这几次作业屡屡犯错。

第一次作业中，难度适中，我拿了及格。但是题量还是挺大的。有一些测试点很难过。我将会在下面进行我的问题分析

第二次作业中主要考察了java中字符串的相关问题，难度适中，我也拿了满分。题量少，没有花太多时间完成本次作业

第三次作业中主要考察了Java中类与对象的实战操作，难度较大，我有一个测试点没有过（好像是基本数据类型的问题），题虽然只有三道，但是一天一道就很难了！，有大量问题困扰我！！！

 

 

设计与分析

在这三次作业中，第二次的7-2作业和第三次作业比较有难度

import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String nums = in.nextLine();
        int j ,h,n=1;
        int yi = 0;
        if(nums.length()<11)
        {
            System.out.print("null data");
            return ;
        }
        for(j =0;j < nums.length(); j++)
        {
            if(nums.charAt(j)=='0') 
            {
                break;
            }
        }
        if(j>=nums.length()) 
        {
            System.out.print("null data");
            return;
        }
        for(int i =0 ;i < nums.length(); i++)
        {
            yi = 0;
            if(nums.charAt(i)=='0')
            {
                {
                    for(h = i;h<i+10;h++)
                    {
                        if(nums.charAt(h)=='0') 
                        {
                            break;
                        }
                    }
                    if(h>=i+10)
                    {
                        System.out.print(n+":");
                        System.out.println("null data");
                        i = i+10;
                        n++;
                        continue;
                    }
                }
                if(nums.charAt(i+10) != '1')
                {
                    System.out.print(n+":");
                    System.out.println("validate error");
                    i=i+10;
                    n++;
                    continue;
                }
                else
                {
                    //System.out.println(i);
                    for(int k =i+1; k<i+9 ;k++)
                    {
                        if(nums.charAt(k)=='1')
                        {
                            yi++;
                            //System.out.println(yi);
                        }
                    }
                    
                    if(yi%2==0) 
                    {
                        if(nums.charAt(i+9)!='1')
                        {
                            System.out.print(n+":");
                            System.out.println("parity check error");
                            i = i+10;
                            n++;
                            continue;
                        }
                        else
                        {
                            System.out.print(n+":");
                            for(int k =i+1; k<i+9 ;k++)
                            {
                                System.out.print(nums.charAt(k));
                            }
                            System.out.println();
                            i=i+10;
                            n++;
                            continue;
                        }
                    }
                    else if(yi%2!=0)
                    {
                        if(nums.charAt(i+9)=='1')
                        {
                            System.out.print(n+":");
                            System.out.println("parity check error");
                            i = i+10;
                            n++;
                            continue;
                        }
                        else
                        {
                            System.out.print(n+":");
                            for(int k =i+1; k<i+9 ;k++)
                            {
                                System.out.print(nums.charAt(k));
                            }
                            System.out.println();
                            i=i+10;
                            n++;
                            continue;
                        }
                    }
                }

            }
        }
    }
}

 

以上是我的源代码
 
解释与心得：
这道题我的入手点是观察输入样例与输出样例，因为这道题很难读懂，要有一定的耐心和观察能力。这次作业对字符串有很深入的使用，所以对于字符串的一些函数要做到得心应手，才能有着高效率去完成这道题
 这道题的错误输入格式比较多，必须要在csdn上搜索相关知识点才能解决
 
 

第三次作业

7-1

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class Point{
  private double x;
    private double y;
    public double getX() {
        return x;
    }
    public void setX(double x) {
        this.x = x;
    }
    public double getY() {
        return y;
    }
    public void setY(double y) {
        this.y = y;
}
}
public class Main {
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
String s;
s = in.nextLine();
check(s);
}

public static void check(String s)
{
String regrex1 = "[+-]?(0|[1-9](\\d+)?)(\\.\\d+)?,[+-]?(0|[1-9](\\d+)?)(\\.\\d+)?[\\s][+-]?(0|[1-9](\\d+)?)(\\.\\d+)?,[+-]?(0|[1-9](\\d+)?)(\\.\\d+)?";
boolean flag = s.matches(regrex1);
if(flag)
{
point(s);
}
else {
int o = 0,m = 0;
for(o=0;o<s.length();o++)
{
if(s.charAt(o)==' ') {
m++;
}
}
if(m>=2){
System.out.println("wrong number of points");
}
else
{
System.out.println("Wrong Format");
}
}
}
public static void point(String s)
{
Point point1 = new Point();
Point point2 = new Point();
Matcher matcher = Pattern.compile("(-?\\d*)\\.?\\d+").matcher(s);
double[] num = new double[4];
int n=0;
while(matcher.find()){
num[n] = Double.valueOf(matcher.group().toString());
n++;
}
point1.setX(num[0]);
point1.setY(num[1]);
point2.setX(num[2]);
point2.setY(num[3]);
length(point1,point2);
}
public static void length(Point point1,Point point2)
{
double length;
double x1,x2,y1,y2;
x1 = point1.getX();
y1 = point1.getY();
x2 = point2.getX();
y2 = point2.getY();
length = Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
System.out.print(length);
}
}

以上是源码

解释与心得：这道题是点线面系列的第一题，综合了较多的知识点，例如正则表达式，在课堂中我并没有完全掌握正则表达式的用途以及含义，但经过现如今的搜索，对于正则表达式以及这道题的了解已经烂熟于心

 
7-2
package nchu_software_oop_2022_3;
import java.util.Scanner;
public class Main2 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        if(str.charAt(0)>='1'&&str.charAt(0)<='5')
        {
            Judge judge = new Judge(str);
            judge.output();
        }
        else
        {
            System.out.println("Wrong Format");
        }
    }
}
class Judge{                                //判断输入字符格式是否满足要求
    
    String str;
    
    public Judge(String str)
    {
        this.str = str;
    }
    
    public void create(int i )                //若满足要求，则调用另一个对象
    {
        Workout work = new Workout(i,str);
        work.compute();
        
    }
    
    public void output()
    {
        int count = 0,count1=0;
        for(int i = 0;i<str.length();i++)
        {
            if(str.charAt(i)==',')
            {
                count++;
            }
            if(str.charAt(i)==' ')
            {
                count1++;
            }
        }
        switch(str.charAt(0)) {
        case '1':
            if(str.matches("[1-5][\\:][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?"))
            {
                create(1);
            }
            else if(count1==2)
            {
                System.out.println("wrong number of points");
            }
            else if(count==3)
            {
                System.out.println("Wrong Format");
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        case '2':
            if(str.matches("[1-5][\\:][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?"))
            {
                create(2);
            }
            else if(count!=3)
            {
                System.out.println("wrong number of points");
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        case '3':
            if(str.matches("[1-5][\\:][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?"))
            {
                create(3);
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        case '4':
            if(str.matches("[1-5][\\:][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s]?"))
            {
                create(4);
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        case '5':
            if(str.matches("[1-5][\\:][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?"))
            {
                create(5);
            }
            else if(count!=4)
            {
                System.out.println("wrong number of points");
            }
            else
            {
                System.out.println("Wrong Format");
            }
            break;
        }
    }
}

class Workout{                                        //满足格式要求后，开始进行数据处理操作
    
    int i;
    String str;
    
    public Workout(int i, String str) 
    {
        this.i = i;
        this.str = str;
    }
    
    public Workout(String str) 
    {
        this.str = str;
    }
    
    public double[] split(String str)                    //对字符串进行分割
    {
        String[] newStr = str.split(",|\\s|:");
        double []num = new double[newStr.length];
        for(int i = 0 ;i < newStr.length; i++)
        {
            num[i] = Double.parseDouble(newStr[i]);
        }
        return num;
    }
    
    
    public void compute()
    {
        double []num = split(str);
        switch((int)num[0]) {
        case 1:
            double slope;
            if(num[1]==num[3])
            {
                if(num[2]==num[4])
                {
                    System.out.println("points coincide");
                }
                else
                {
                    System.out.println("Slope does not exist");                    
                }
            }
            else
            {
                slope = (num[2]-num[4])/(num[1]-num[3]);
                System.out.println(slope);
            }
            break;
        case 2:
            if(num[3]==num[5]&&num[4]==num[6])
            {
                System.out.println("points coincide");
                return;
            }
            if(num[3] == num[5]&&num[4]!=num[6])
            {
                System.out.println(Math.abs(num[1]-num[5]));
            }
            else
            {
                double k = (num[4]-num[6])/(num[3]-num[5]);
                double b = num[4]-k*num[3];
                double d = (k*num[1]+b-num[2])/(Math.sqrt(1+k*k));
                System.out.println(Math.abs(d));
            }
            break;
        case 3:
            if(num[1]==num[3]&&num[2]==num[4]||num[5]==num[1]&&num[6]==num[2]||num[5]==num[3]&&num[6]==num[4])
            {
                System.out.println("points coincide");
                return;
            }
            if(num[1]!=num[3]&&num[5]!=num[3])
            {
                double slope3_1 = (num[2]-num[4])/(num[1]-num[3]);
                double slope3_2 = (num[6]-num[4])/(num[5]-num[3]);
                System.out.println(Math.abs(slope3_1-slope3_2)<0.00001);
            }
            else if(num[1]==num[3]&&num[5]==num[3])
            {
                System.out.println("true");
            }
            else
            {
                System.out.println("false");
            }
            break;
        case 4:
            if(num[1]==num[3]&&num[2]==num[4]||num[5]==num[7]&&num[6]==num[8])
            {
                System.out.println("points coincide");
                return;
            }
            if(num[1]!=num[3]&&num[5]!=num[7]&&num[1]!=num[5])
            {
                double slope4_1 = (num[2]-num[4])/(num[1]-num[3]);
                double slope4_2 = (num[6]-num[8])/(num[5]-num[7]);
                System.out.println(Math.abs(slope4_1-slope4_2)<0.00001);
            }
            else if(num[1]==num[3]&&num[5]==num[7])
            {
                System.out.println("true");
            }
            else
            {
                System.out.println("false");
            }
            break;
        case 5:
            if(num[1]==num[3]&&num[2]==num[4]||num[5]==num[7]&&num[6]==num[8])
            {
                System.out.println("points coincide");
                return;
            }
            if(num[1]==num[3]&&num[5]==num[7]&&num[1]!=num[5])
            {
                System.out.println("is parallel lines,have no intersection point");
            }
            else
            {
                double slope5_1 = 0;
                double slope5_2 = 0;
                double b5_1 = 0;
                double b5_2 = 0;
                if(num[3]==num[1]&&num[7]!=num[5])
                {
                    slope5_2 = (num[6]-num[8])/(num[5]-num[7]);
                    b5_2 = num[8] - slope5_2*num[7];
                    double y = slope5_2*num[1]+b5_2;
                    double d = Math.abs(y-num[2])+Math.abs(y-num[4]);
                    double a = Math.sqrt(Math.pow(num[1]-num[5], 2) + Math.pow(y-num[6], 2));
                    double b = Math.sqrt(Math.pow(num[1]-num[7], 2) + Math.pow(y-num[8], 2));
                    double c = Math.sqrt(Math.pow(num[5]-num[7], 2) + Math.pow(num[6]-num[8], 2));
                    if(Math.abs(y-num[2])<0.0001||Math.abs(y-num[4])<0.0001||Math.abs(num[1]-num[5])<0.0001||Math.abs(num[1]-num[7])<0.0001)
                    {
                        System.out.println(num[1]+","+y+" "+"false");
                    }
                    else
                    System.out.println(num[1]+","+y+" "+(Math.abs(d-Math.abs(num[2]-num[4]))<0.00001||Math.abs(a+b-c)<0.00001));
                }
                else if(num[3]!=num[1]&&num[7]==num[5])
                {
                    slope5_1 = (num[2]-num[4])/(num[1]-num[3]);
                    b5_2 = num[2] - slope5_1*num[1];
                    double y = slope5_1*num[5]+b5_2;
                    double d = Math.abs(y-num[6])+Math.abs(y-num[8]);
                    double a = Math.sqrt(Math.pow(num[1]-num[5], 2) + Math.pow(y-num[2], 2));
                    double b = Math.sqrt(Math.pow(num[3]-num[5], 2) + Math.pow(y-num[4], 2));
                    double c = Math.sqrt(Math.pow(num[1]-num[3], 2) + Math.pow(num[2]-num[4], 2));
                    if(Math.abs(y-num[6])<0.0001||Math.abs(y-num[8])<0.0001||Math.abs(num[5]-num[1])<0.0001||Math.abs(num[5]-num[3])<0.0001)
                    {
                        System.out.println(num[5]+","+y+" "+"false");
                    }
                    else
                    System.out.println(num[5]+","+y+" "+(Math.abs(d-Math.abs(num[2]-num[4]))<0.00001||Math.abs(a+b-c)<0.00001));
                }
                else
                {
                    slope5_1 = (num[2]-num[4])/(num[1]-num[3]);
                    slope5_2 = (num[6]-num[8])/(num[5]-num[7]);
                    if(Math.abs(slope5_2-slope5_1)<0.00001)
                    {
                        if(num[1]!=num[5])
                        System.out.println("is parallel lines,have no intersection point");
                    }
                    else
                    {
                        b5_1 = num[2] - slope5_1*num[1];
                        b5_2 = num[8] - slope5_2*num[7];
                        double x1 = ((b5_1-b5_2)/(slope5_2-slope5_1));
                        double y1 = ((b5_1*slope5_2-b5_2*slope5_1)/(slope5_2-slope5_1));
                        double a = Math.sqrt(Math.pow(x1-num[1], 2) + Math.pow(y1-num[2], 2));
                        double b = Math.sqrt(Math.pow(x1-num[3], 2) + Math.pow(y1-num[4], 2));
                        double c = Math.sqrt(Math.pow(num[1]-num[3], 2) + Math.pow(num[2]-num[4], 2));
                        double a1 = Math.sqrt(Math.pow(x1-num[5], 2) + Math.pow(y1-num[6], 2));
                        double b1 = Math.sqrt(Math.pow(x1-num[7], 2) + Math.pow(y1-num[8], 2));
                        double c1 = Math.sqrt(Math.pow(num[5]-num[7], 2) + Math.pow(num[6]-num[8], 2));
                        System.out.println((float)x1+","+(float)y1+" "+(Math.abs(a+b-c)<0.00001||Math.abs(a1+b1-c1)<0.00001));
                    }
                }
            }
            break;
        }
    }
}

 以上是源码

解释与心得：

第二题他这个分为五个小题，每一题用一个方法来写就可以，第二题可以用第一题的点创造一个点来解题，具体的使用我还不是很会。我来讲一下我写每一个类遇到的困难。正常的代码都是简单的数学问题没有什么好说的，主要是不同题目他正则表达式的第一个是不同的如果他有很多坐标就在后面多加几个坐标类型，多添加几个子字符串就可以得到他们的数字，还有几个测试点过不了我也不知道为什么，就改一下他就会错很多，真的很没用办法，试了很多次没有结果我就不试了。但是这次我的Main函数代码显得简洁起来了，但是好像又过于简洁相比于之前，我这次的代码已经有了很大的进步。

 

7-3import java.text.DecimalFormat;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        if(str.charAt(0)>='1'&&str.charAt(0)<='5')
        {
            Judge judge = new Judge(str);
            judge.output();
        }
        else
        {
            System.out.println("Wrong Format");
        }
    }
}
class Judge{                                //判断输入字符格式是否满足要求
        
        String str;
        public Judge(String str)
        {
            this.str = str;
        }
        public void create(int i )                //若满足要求，则调用另一个对象
        {
            Workout work = new Workout(i,str);
            work.compute();
            
        }
        public void output()
        {
            int count = 0,count1=0;
            for(int i = 0;i<str.length();i++)
            {
                if(str.charAt(i)==',')
                {
                    count++;
                }
                if(str.charAt(i)==' ')
                {
                    count1++;
                }
            }
            switch(str.charAt(0)) {
            case '1':
                if(str.matches("[1-5][\\:][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?"))
                {
                    create(1);
                }
                
                else
                {
                    System.out.println("Wrong Format");
                }
                break;
            case '2':
                if(str.matches("[1-5][\\:][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?"))
                {
                    create(2);
                }
                
                else
                {
                    System.out.println("Wrong Format");
                }
                break;
            case '3':
                if(str.matches("[1-5][\\:][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?"))
                {
                    create(3);
                }
                    
                else
                {
                    System.out.println("Wrong Format");
                }
                break;
            case '4':
                if(str.matches("[1-5][\\:][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?"))
                {
                    create(4);
                }
                else if(count!=5)
                {
                    System.out.println("wrong number of points");
                }
                else
                {
                    System.out.println("Wrong Format");
                }
                break;
            case '5':
                if(str.matches("[1-5][\\:][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\s][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?[\\,][+-]?(0|[1-9][\\d]{0,})(\\.[\\d]{1,})?"))
                {
                    create(5);
                }
                else
                {
                    System.out.println("Wrong Format");
                }
                break;
            }
        }
    }

class Workout{                                        //满足格式要求后，开始进行数据处理操作
        
        int i;
        String str;
        
        public Workout(int i, String str) 
        {
            this.i = i;
            this.str = str;
        }
        
        public Workout(String str) 
        {
            this.str = str;
        }
        
        public float[] split(String str)                    //对字符串进行分割
        {
            String[] newStr = str.split(",|\\s|:");
            float []num = new float[newStr.length];
            for(int i = 0 ;i < newStr.length; i++)
            {
                num[i] = Float.parseFloat(newStr[i]);
            }
            return num;
        }
        
        
        public void compute()
        {
            DecimalFormat df = new DecimalFormat("0.0#####");
            float []num = split(str);
            switch((int)num[0]) {
            case 1:
                float a = (num[1]-num[3])*(num[1]-num[3])+(num[2]-num[4])*(num[2]-num[4]);
                float b = (num[1]-num[5])*(num[1]-num[5])+(num[2]-num[6])*(num[2]-num[6]);
                float c = (num[3]-num[5])*(num[3]-num[5])+(num[4]-num[6])*(num[4]-num[6]);
                if(num[1]==num[3]&&num[1]==num[5]||num[2]==num[4]&&num[2]==num[6])
                {
                    System.out.print("data error");
                    return;
                }
                if(Math.abs(a-c)<0.001||Math.abs(a-b)<0.001||Math.abs(b-c)<0.001)
                {
                    System.out.print("true"+" ");
                }
                else
                    System.out.print("false"+" ");
                if(Math.abs(a-c)<0.001&&Math.abs(a-b)<0.001&&Math.abs(b-c)<0.001)
                {
                    System.out.println("true");
                }
                else
                {
                    System.out.println("false");
                }
                break;
            case 2:
                double a2 =  Math.sqrt((num[1]-num[3])*(num[1]-num[3])+(num[2]-num[4])*(num[2]-num[4]));
                double b2 =  Math.sqrt((num[1]-num[5])*(num[1]-num[5])+(num[2]-num[6])*(num[2]-num[6]));
                double c2 =  Math.sqrt((num[3]-num[5])*(num[3]-num[5])+(num[4]-num[6])*(num[4]-num[6]));
                if(num[1]==num[3]&&num[1]==num[5]||num[2]==num[4]&&num[2]==num[6])
                {
                    System.out.print("data error");
                    return;
                }
                double p = (a2+b2+c2)/2;
                double line = a2+b2+c2;
                double area =  Math.sqrt(p*(p-a2)*(p-b2)*(p-c2));
                System.out.print(df.format(line)+" "+df.format(area)+" ");
                System.out.print(df.format((num[1]+num[3]+num[5])/3)+","+df.format((num[2]+num[4]+num[6])/3));
                break;
            case 3:
                double a3 =  (num[1]-num[3])*(num[1]-num[3])+(num[2]-num[4])*(num[2]-num[4]);
                double b3 =  (num[1]-num[5])*(num[1]-num[5])+(num[2]-num[6])*(num[2]-num[6]);
                double c3 =  (num[3]-num[5])*(num[3]-num[5])+(num[4]-num[6])*(num[4]-num[6]);
                if(num[1]==num[3]&&num[1]==num[5]||num[2]==num[4]&&num[2]==num[6])
                {
                    System.out.print("data error");
                    return;
                }
                if(a3+b3<c3||c3+b3<a3||a3+c3<b3)
                {
                    System.out.print("true ");
                    System.out.print("false ");
                    System.out.print("false");
                }
                else
                {
                    if(a3+b3>c3&&c3+b3>a3&&a3+c3>b3)
                    {
                        System.out.print("false ");
                        System.out.print("false ");
                        System.out.print("true");
                    }
                    else
                    {
                        System.out.print("false ");
                        System.out.print("true ");
                        System.out.print("false");
                    }
                }
                break;
            case 4:
                if(num[1]==num[3]&&num[2]==num[4])
                {
                    System.out.println("points coincide");
                    return;
                }
                if(num[5]==num[7]&&num[5]==num[9]||num[6]==num[8]&&num[6]==num[10])
                {
                    System.out.print("data error");
                    return;
                }
                Point p1 = new Point(num[1],num[2]);
                Point p2 = new Point(num[3],num[4]);
                Point pa = new Point(num[5],num[6]);
                Point pb = new Point(num[7],num[8]);
                Point pc = new Point(num[9],num[10]);
                Line line1 = new Line(p1,p2);
                Line linea = new Line(pb,pc);
                Line lineb = new Line(pa,pc);
                Line linec = new Line(pa,pb);
                Area area1 = new Area(pa,pb,pc);
                if(line1.is_inline(pa)&&line1.is_inline(pb)||line1.is_inline(pa)&&line1.is_inline(pc)||line1.is_inline(pb)&&line1.is_inline(pc))
                {
                    System.out.println("The point is on the edge of the triangle");
                    return;
                }
                if(line1.is_inline(pa))
                {
                    if(line1.is_parallel(linea))
                    {
                        System.out.println("1");
                        return;
                    }
                    Point pA = new Point();
                    pA = line1.intersection(linea);
                    if(linea.is_inlineSegment(pA))
                    {
                        Area s1 = new Area(pa,pb,pA);
                        System.out.println("2"+" "+df.format(Math.min(area1.calculate()-s1.calculate(),s1.calculate()))+" "+df.format(Math.max(area1.calculate()-s1.calculate(),s1.calculate())));
                        return ;
                    }
                    else 
                    {
                        System.out.println("1");
                        return;
                    }
                }
                else if(line1.is_inline(pb))
                {
                    if(line1.is_parallel(lineb))
                    {
                        System.out.println("1");
                        return;
                    }
                    Point pB = new Point();
                    pB = line1.intersection(lineb);
                    if(lineb.is_inlineSegment(pB))
                    {
                        Area s1 = new Area(pa,pb,pB);
                        System.out.println("2"+" "+df.format(Math.min(area1.calculate()-s1.calculate(),s1.calculate()))+" "+df.format(Math.max(area1.calculate()-s1.calculate(),s1.calculate())));
                        return;
                    }
                    else 
                    {
                        System.out.println("1");
                        return;
                    }
                }
                else if(line1.is_inline(pc))
                {
                    if(line1.is_parallel(linec))
                    {
                        System.out.println("1");
                        return;
                    }
                    Point pC = new Point();
                    pC = line1.intersection(linec);
                    if(linec.is_inlineSegment(pC))
                    {
                        Area s1 = new Area(pb,pc,pC);
                        System.out.println("2"+" "+df.format(Math.min(area1.calculate()-s1.calculate(),s1.calculate()))+" "+df.format(Math.max(area1.calculate()-s1.calculate(),s1.calculate())));
                        return;
                    }
                    else 
                    {
                        System.out.println("1");
                        return;
                    }
                }
                if(line1.is_parallel(linea))
                {
                      Point pB = new Point();
                      pB = line1.intersection(lineb);
                      if(lineb.is_inlineSegment(pB))
                      {
                          double s1 = Math.pow(line1.getDistance(pa)/linea.getDistance(pa),2)*area1.calculate();
                          System.out.println("2"+" "+df.format(Math.min(s1,area1.calculate()-s1))+" "+df.format(Math.max(s1,area1.calculate()-s1)));
                          return;
                      }
                      else
                      {
                          System.out.println("0");
                          return;
                      }
                          
                }
                else if(line1.is_parallel(lineb))
                {
                      Point pA = new Point();
                      pA = line1.intersection(linea);
                      if(linea.is_inlineSegment(pA))
                      {
                          double s1 = Math.pow(line1.getDistance(pb)/lineb.getDistance(pb),2)*area1.calculate();
                          System.out.println("2"+" "+df.format(Math.min(s1,area1.calculate()-s1))+" "+df.format(Math.max(s1,area1.calculate()-s1)));
                          return;
                      }
                      else
                      {
                          System.out.println("0");
                          return;
                      }
                         
                }
                else if(line1.is_parallel(linec))
                {
                      Point pB = new Point();
                      pB = line1.intersection(lineb);
                      if(lineb.is_inlineSegment(pB))
                      {
                          double s1 = Math.pow(line1.getDistance(pc)/linec.getDistance(pc),2)*area1.calculate();
                          System.out.println("2"+" "+df.format(Math.min(s1,area1.calculate()-s1))+" "+df.format(Math.max(s1,area1.calculate()-s1)));
                          return;
                      }
                      else
                      {
                          System.out.println("0");
                          return;
                      }
                }
                else{
                    int count = 0;
                    Point pA = new Point();
                    Point pB = new Point();
                    Point pC = new Point();
                    pA = line1.intersection(linea);
                    pB = line1.intersection(lineb);
                    pC = line1.intersection(linec);
                    if(linea.is_inlineSegment(pA))
                    {
                        count++;
                    }

                    if(lineb.is_inlineSegment(pB))
                    {
                        count++;
                    }
             
                    if(linec.is_inlineSegment(pC))
                    {
                        count++;
                    }
                    if(count==2)
                    {
                        if((linea.is_inlineSegment(pA))&&(lineb.is_inlineSegment(pB)))
                        {
                            Area s = new Area(pA,pB,pc);
                            System.out.println(count+" "+df.format(Math.min(area1.calculate()-s.calculate(),s.calculate()))+" "+df.format(Math.max(area1.calculate()-s.calculate(),s.calculate())));
                        }
                        else if((linea.is_inlineSegment(pA))&&(linec.is_inlineSegment(pC)))
                        {
                            Area s = new Area(pA,pC,pb);
                            System.out.println(count+" "+df.format(Math.min(area1.calculate()-s.calculate(),s.calculate()))+" "+df.format(Math.max(area1.calculate()-s.calculate(),s.calculate())));
                        }
                        else if((lineb.is_inlineSegment(pB))&&(linec.is_inlineSegment(pC)))
                        {
                            Area s = new Area(pB,pC,pa);
                            System.out.println(count+" "+df.format(Math.min(area1.calculate()-s.calculate(),s.calculate()))+" "+df.format(Math.max(area1.calculate()-s.calculate(),s.calculate())));
                        }
                    }
                    else
                    {
                        System.out.println(count);
                    }
                }
                break;
            case 5:
                if(num[5]==num[7]&&num[5]==num[3]||num[6]==num[8]&&num[6]==num[4])
                {
                    System.out.print("data error");
                    return;
                }
                Point P = new Point(num[1],num[2]);
                Point P1 = new Point(num[3],num[4]);
                Point P2 = new Point(num[5],num[6]);
                Point P3 = new Point(num[7],num[8]);
                Line lineA = new Line(P1,P2);
                Line lineB = new Line(P2,P3);
                Line lineC = new Line(P3,P1);
                if(lineA.is_inline(P)&&lineA.is_inlineSegment(P)||lineB.is_inline(P)&&lineB.is_inlineSegment(P)||lineC.is_inline(P)&&lineC.is_inlineSegment(P))
                {
                    System.out.println("on the triangle");
                    return;
                }
                else
                {
                    Area s = new Area(P1,P2,P3);
                    Area s1 = new Area(P,P2,P3);
                    Area s2 = new Area(P1,P,P3);
                    Area s3 = new Area(P1,P2,P);
                    if(Math.abs(s1.calculate()+s2.calculate()+s3.calculate()-s.calculate())<0.00001)
                    {
                        System.out.println("in the triangle");
                    }
                    else
                    {
                        System.out.println("outof the triangle");
                    }
                }
                break;
            }
        }
}
class Point
{
    double x;
    double y;
    
    public Point() {}
    public Point(double x, double y) 
    {
        this.x = x;
        this.y = y;
    }
    public double getDistance(Point p)//计算两点之间的距离
    {
        double distance = 0;
        distance = Math.sqrt(Math.pow(x-p.x,2)+Math.pow(y-p.y,2));
        return distance;
    }
    public boolean equal(Point p)
    {
        if(p.x==x&&p.y==y) {
            return true;
        }
        else {
            return false;
        }
    }
}

class Line
{
    Point p1;
    Point p2;
    
    public Line(Point p1, Point p2) {
        super();
        this.p1 = p1;
        this.p2 = p2;
    }
    
    public boolean is_Slope()//判断斜率是否存在
    {
        if(p1.x==p2.x)
        {
            return false;
        }
        return true;
    }
    
    public double getSlope()//计算斜率
    {
        double slope = 0;
        slope = (p1.y-p2.y)/(p1.x-p2.x);
        return slope;
    }
    
    public double getDistance(Point p)//计算点到直线的距离
    {
        if(is_Slope())
        {
            double k = (p1.y-p2.y)/(p1.x-p2.x);
            double b = p1.y-k*p1.x;
            double d = (k*p.x+b-p.y)/(Math.sqrt(1+k*k));
            return Math.abs(d);
        }
        else
        {
            return Math.abs(p.x-p1.x);
        }
    }
    
    //p1,p2是该线本身的两个端点
    public boolean is_parallel(Line line)
    {
        if(is_Slope()&&line.is_Slope())
        {
            
            double k1 = getSlope();
            double k2 = line.getSlope();
            return ((Math.abs(k1-k2)<0.00001));
        }
        else if((!is_Slope()&&line.is_Slope())||(is_Slope()&&!line.is_Slope()))
        {
            return false;
        }
        else if(!is_Slope()&&!line.is_Slope())
        {
            return true;
        }
        else return false;
    }
    
    public boolean is_inline(Point p)//判断点是否在线上
    {
        Line line1 = new Line(p1,p);
        Line line2 = new Line(p1,p2);
        Line line3 = new Line(p2,p);
        if(line1.is_Slope()&&line2.is_Slope())
        {
            if(Math.abs(line1.getSlope()-line2.getSlope())<0.0001)
            {
                return true;
            }
        }
        else if(p.equal(p1)||p.equal(p2)||p1.equal(p2))
        {
            return true;
        }
        else if(p1.x==p2.x&&p2.x==p.x)
        {
            return true;
        }
        return false;
        
    }
    
    public boolean is_inlineSegment(Point p)
    {
        if(p.x>=Math.min(p1.x,p2.x)&&p.x<=Math.max(p1.x,p2.x)&&p.y>=Math.min(p1.y,p2.y)&&p.y<=Math.max(p1.y,p2.y))
        {
            return true;
        }
        return false;
    }
    
    public Point intersection(Line line)
    {
        Point p0 = new Point();
        if(!is_parallel(line))
        {
            if(!is_Slope()&&line.is_Slope())
            {
                p0.x = p1.x;
                double k2 = line.getSlope();
                double b2 = line.p1.y-k2*line.p1.x;
                p0.y = k2*p0.x+b2;
            }
            else if(is_Slope()&&!line.is_Slope())
            {
                p0.x = line.p1.x;
                double k1 = getSlope();
                double b1 = p1.y-k1*p1.x;
                p0.y = k1*p0.x+b1;
            }
            else
            {
                double k1 = getSlope();
                double k2 = line.getSlope();
                double b1 = p1.y-k1*p1.x;;
                double b2 = line.p1.y-k2*line.p1.x;
                p0.x = (b1-b2)/(k2-k1);
                p0.y = (b1*k2-b2*k1)/(k2-k1);
            }
        }
        return p0;
    }
}

class Area
{
    Point p1;
    Point p2;
    Point p3;
    
    public Area(Point p1, Point p2, Point p3) {
        super();
        this.p1 = p1;
        this.p2 = p2;
        this.p3 = p3;
    }

    public double calculate()
    {
        double a = p1.getDistance(p2);
        double b = p2.getDistance(p3);
        double c = p3.getDistance(p1);
        double p = (a+b+c)/2;
        double area = Math.sqrt(p*(p-a)*(p-b)*(p-c));
        return area;
    }
}
以上是源码

解释与心得：把正则表达式以及每个case中的语句进行了代换，这使我我的代码显得十分多，回顾和总结当然简单的代码只能是很初级的生命体。
如果只是几行几十行的代码，你即使是背不会，也基本上完全掌握它的来龙去脉，你充分的理解它，你可以完全的掌控它的每个逻辑细节。它就像
一个最简单的单细胞生物一样，你可以完全的掌控它。然而对于这道题最简单的就是Point类了，属性只含两个点坐标，行为也只有getDistance()
和equal();但是线类就显得很繁琐了，在我看来，一条线的属性并不是他的斜率和截距，而是两个点。因为你无法保证这个点一定存在斜率，所以两
个点可以完全考虑所有情况

踩坑心得

第一次作业，在第一次作业中，第一次遇到正则表达式类型题目，对于当时一窍不通的我，花了好长时间才理解贯通

第二次作业，我记得在第二次作业中，错把while循环当成了for循环，以至于无论怎么改都改不对。
第三次作业，在第三次作业中，综合了前两题的所有知识点，以至于当时做不出来第二题的时候想直接跳到第三题却当时蒙圈的感觉。


改进建议

希望pta在今后可以让同学们找到每个编译点的问题所在，以至于不必再一点点去找到到底是哪步出现了问题

    总结

   1.希望老师多加结合平时上课所学知识点去出相应的pta题目，我的意思是更加贴切。

   2.作业截至以后，我认为老师可以组织我们一起更深层次的去挖掘题目深层

   3.上课的时候可以减少学习通布置作业让大家思考，可以课后在思考和更好的学会掌握。













            

            
posted @ 
2022-04-11 09:32 
21201634-赵修培 
阅读(42) 
评论(0) 
 
收藏 
举报