11222的第一次博客作业

一、前言

二、设计与分析

三、采坑心得

四、改进建议

五、总结

-----------------------------------------------------------------------------------------------------------------------------------------

前言

新学期开始学习java语言，与上学期所学习的C语言有所不同，在自学前八章的基础上学习之后的内

容在学习的过程中老师在PTA平台上发布了三次题目集作为我们练习的作业。每次发布的题目集的作业都

有不同的知识点、题量、难度等情况。

题目集一：在题目集一中共布置了九道题，主要了考察对Java语言不同数据类型的运用、字符串类型

数据的处理、循环和判断等其他知识点的运用。

题目集二：在题目集二中共布置了三道题，主要考察了对Java语言中String的格式判断、内容提取和

内容判断等其他知识的运用。

题目集三：在题目集三中布置了三道题，主要考察了对Java语言中类的创建和使用、String的格式判

断、内容提取和内容判断等其他知识的运用。

总体难度比C语言的高。

------------------------------------------------------------------------------------------------------------------------------------------

设计与分析

题目集二————7-2 串口字符解析

RS232是串口常用的通信协议，在异步通信模式下，串口可以一次发送5~8位数据，收发双方之间没有数据

发送时线路维持高电平，相当于接收方持续收到数据“1”（称为空闲位），发送方有数据发送时，会在有效数

据（5~8位，具体位数由通信双方提前设置）前加上1位起始位“0”，在有效数据之后加上1位可选的奇偶校验

位和1位结束位“1”。请编写程序，模拟串口接收处理程序，注：假定有效数据是8位，奇偶校验位采用奇校验。

输入格式:

由0、1组成的二进制数据流。例如：11110111010111111001001101111111011111111101111

输出格式:

过滤掉空闲、起始、结束以及奇偶校验位之后的数据，数据之前加上序号和英文冒号。
如有多个数据，每个数据单独一行显示。
若数据不足11位或者输入数据全1没有起始位，则输出"null data"，
若某个数据的结束符不为1，则输出“validate error”。
若某个数据奇偶校验错误，则输出“parity check error”。
若数据结束符和奇偶校验均不合格，输出“validate error”。
如：11011或11111111111111111。
例如：
1:11101011
2:01001101
3:validate error

分析：

该题是对输入的字符串进行判定并进行相应的操作和输出；

设计：

编写方法来判断所输入的字符串是否符合标准形式，返回true/false;使主方法简单些。

在主方法里继续判断数据里的内容是否有错误，无错便输出。

代码实现：

 1 import java.util.Scanner;
 2 
 3 public class Main {
 4     public static void main(String[] args) {
 5         Scanner in=new Scanner(System.in);
 6     String num=in.nextLine();
 7    boolean flag=false;
 8    flag=whole(num);
 9    int j=1,i;
10          if(num.length()<11||flag)
11          {
12              System.out.println("null data");
13          }
14          else
15          for(i = 0;i<num.length();)
16          {
17              char a=num.charAt(i);
18              if(num.length()-i<10)
19                  break;
20              if(a=='0')
21              {            
22                  if(num.length()-i==10)
23                  {
24                      String temp=num.substring(i+1);
25                  }
26                  else
27                  {
28                  String temp=num.substring(i+1,i+11);
29                  i=i+11;
30                  if(temp.charAt(9)=='1')
31                  {
32                      if(jishu(temp))
33                      {
34                          System.out.println(j+":"+temp.substring(0,8));
35                          j++; 
36                      }else 
37                      {
38                          System.out.println(j+":"+"parity check error");
39                          j++;
40                      }
41                  }
42                  else 
43                  {
44 //                     if(jishu(temp)==false)
45 //                     {
46 //                         System.out.print(j+":"+"validate error");
47 //                         j++;
48 //                     }
49                      System.out.println(j+":"+"validate error");
50                      j++; 
51                  }
52                  }
53              }else
54                  i++;
55          }
56     }
57      
58      public static boolean whole(String num)
59      {
60          boolean flag=false;
61          for(int i = 0;i<num.length();i++)
62          {
63              if(num.charAt(i)=='1')
64              {
65              flag=true;
66              }
67              else
68              {
69                  flag=false;
70                  break;
71              }
72          }
73          return flag;
74      }
75 
76      public static boolean jishu(String temp)
77      {
78          int k=0;
79          for(int i=0;i<9;i++)
80          {
81              if(temp.charAt(i)=='1')
82                  k++;                 
83          }
84          if(k%2==0)
85          {
86              return false;
87          }
88          else 
89          {
90              return true;
91          }
92      }
93 }

踩坑心得：

1、单个字符比较用' '符号，多个字符用" "符号。

2、求字符串长度用length()方法，求数组长度用length方法；

3、读懂题目很重要。

改进建议：

1、可以尝试构建一个类来处理传入数据降低耦合性

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

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

输入格式:

4个double类型的实数，两个点的x，y坐标，依次是x1、y1、x2、y2，两个点的坐标之间以空格分隔，每个点的x,y坐标以英文“,”分隔。例如：0,0 1,1或0.1,-0.3 +3.5,15.6。
若输入格式非法，输出"Wrong Format"。
若输入格式合法但坐标点的数量超过两个，输出“wrong number of points”。

输出格式:

计算所得的两点之间的距离。例如：1.4142135623730951

分析：

输入的数据格式应为字符串，应改对字符串进行处理再用处理所得的数据用于计算。

设计：

构造一个类来处理字符串，该类应有能判断格式错误的功能。

代码实现：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
    points a=new points();
        a.show();
    }
}

class points
{
    Scanner in=new Scanner(System.in);
    String s;
    double [] nums=new double[10];
    points()
    {
        s=in.nextLine();
        getnums(s);
        
    }
    
    void getnums(String s)
    {
        String a[]=s.split("\\s");
        int k=0;
        if(a.length>1)
        {
            for(int i=0;i<a.length;i++)
            {
                String d[]=a[i].split(",");
                if(d.length==2)
                {
                    for(int j=0;j<d.length;j++)
                    {
                        nums[k]=num(d[j]);
                        k++;
                    }
                }
                else//格式非法
                {
                    System.out.print("Wrong Format");
                    System.exit(0);
                }
            }
            if(a.length>2)//输入格式合法但坐标点的数量超过两个
            {
                System.out.print("wrong number of points");
                System.exit(0);
            }
            
        }
        else//格式非法
        {            
            System.out.print("Wrong Format");
            System.exit(0);
        }
        
    }
    
    void show()
    {
        System.out .print(Math.sqrt(Math.pow(nums[2]-nums[0], 2)+Math.pow(nums[3]-nums[1], 2)));
        
    }
    
    double num(String q)
    {
        double p=0;
        int k=0,l=0,y=0,j=0;
        for(int i=0;i<q.length();i++)
        {
            if(q.charAt(i)=='+'||q.charAt(i)=='-')
            {
                k=i;
                y++;
            }
            if(q.charAt(i)=='.')
            {
                l=i;
                j++;
            }
            
            if(j>1||y>1)
          {
            System.out.println("Wrong Format");//格式错误
            System.exit(0);    
          }
        }
        if(l==q.length()||k==q.length()||(q.charAt(0)=='.')||(k>0&&k<q.length()))
        {
            System.out.println("Wrong Format");//格式错误
            System.exit(0);
        }
        if((q.charAt(0)=='+'&&q.charAt(1)=='+')||(q.charAt(0)=='-'&&q.charAt(1)=='-')||(q.charAt(0)=='+'&&q.charAt(1)=='-')||(q.charAt(0)=='-'&&q.charAt(1)=='+')||(q.charAt(0)=='.'))
        {
            System.out.print("Wrong Format");//格式错误
            System.exit(0);
        }
        else
        {
            p=Double.parseDouble(q);
        }
        return p;
    }
}

踩坑心得：

1、判断错误后要直接终止程序，不然程序继续运行会输出不需要的东西。

2、求字符串长度用length()方法，求数组长度用length方法；

3、读懂题目很重要。

改进建议：

1、用正则表达式来判断验证输入。

题目集三————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"，

输出格式:

见题目描述。

分析：

输入的数据格式应为字符串，应改对字符串进行处理再用处理所得的数据用于计算。

设计：

用类来处理输入的字符串，用switch来选择题目要求的五种运算方法。

数据处理方式和上一题差不多可以将第一题里的类复制过来修改一部分就能使用，再构造题目里所需要的五种方法。

代码实现

import java.util.Scanner;

public class Main {
/*用户输入一组选项和数据，进行与直线有关的计算。选项包括：

 */
    
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in=new Scanner(System.in);
        String s=in.nextLine();
        String n=s.substring(0,2);
        s=s.substring(2);
        int x;
        x=option(n);
        points_1 a=new points_1(s,x);
        a.show();
    }
    
static int option(String n)
{
    int x=0;
    if((n.charAt(0)>='1'||n.charAt(0)<='5')&&n.charAt(1)==':')
    {
        x=Integer.parseInt(n.substring(0,1));
        return x;
    }
    else
    {
        System.out.println("Wrong Format");//格式错误
        System.exit(0);
        return x;//没用但不加报错，牛马
    }
    
}

}

 class points_1
{
    Scanner in=new Scanner(System.in);
    String s;
    int n;//所勾选运算方法
    int m;//点数
    double [] nums=new double[10];
    points_1(String s,int x)
    {    
        this.n=x;
        switch(n)
        {
        case 1:
            m=2;
            break;
        case 2:case 3:
            m=3;
            break;
        case 4:case 5:
            m=4;
            break;
        }
        getnums(s);
    }
    
    void getnums(String s)//拆分数据并判断格式是否正确
    {
        String a[]=s.split("\\s");
        int k=0;
        if(a.length>1)
        {
            for(int i=0;i<a.length;i++)
            {
                String d[]=a[i].split(",");
                if(d.length==2)
                {
                    for(int j=0;j<d.length;j++)
                    {
                        nums[k]=num(d[j]);
                        k++;
                    }
                }
                else//格式非法
                {
                    System.out.println("Wrong Format");
                    System.exit(0);
                }
            }
            if(a.length>m)//输入格式合法但坐标点的数量超过两个
            {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            
        }
        else//格式非法
        {            
            System.out.println("Wrong Format");
            System.exit(0);
        }
        option_1();
    }
    
    double num(String q)//数据转换
    {
        double p=0;
        if((q.charAt(0)=='+'&&q.charAt(1)=='+')||(q.charAt(0)=='-'&&q.charAt(1)=='-'))
        {
            System.out.println("Wrong Format");//格式错误
            System.exit(0);
        }
        else
        {
            p=Double.parseDouble(q);
        }
        return p;
    }
    void option_1()//判断输入点是否相同
    {
        switch(n)//不论哪个选项，如果格式、点数量都符合要求，但构成任一条线的两个点坐标重合，输出"points coincide"，
        {
        case 1:
            if(nums[0]==nums[2]&&nums[1]==nums[3])
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            break;
        case 2:
            if((nums[0]==nums[2]&&nums[1]==nums[3])||(nums[2]==nums[4]&&nums[3]==nums[5])||(nums[0]==nums[4]&&nums[1]==nums[5]))
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            break;
        case 3:
            if((nums[0]==nums[2]&&nums[1]==nums[3])||(nums[2]==nums[4]&&nums[3]==nums[5])||(nums[0]==nums[4]&&nums[1]==nums[5]))
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            break;
        case 4:
            if((nums[0]==nums[2]&&nums[1]==nums[3])||(nums[4]==nums[6]&&nums[5]==nums[7]))
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            break;
        case 5:
            if((nums[0]==nums[2]&&nums[1]==nums[3])||(nums[4]==nums[6]&&nums[5]==nums[7]))
            {
                System.out.println("points coincide");
                System.exit(0);
            }
            break;
        }
    }
    void show()
    {
        switch(n)
        {
        case 1:
            show_1();
            break;
        case 2:
            show_2();
            break;
        case 3:
            show_3();
            break;
        case 4:
            show_4();
            break;
        case 5:
            show_5();
            break;
            
        }
    }
//    1：输入两点坐标，计算斜率，若线条垂直于X轴，输出"Slope does not exist"。
    void show_1()
    {
        double k=0;
        k=(nums[3]-nums[1])/(nums[2]-nums[0]);            
        if(Math.abs(nums[2]-nums[0])<0.001)
        {
            System.out .print("Slope does not exist");
        }
        else
        {
            System.out .print(k);
        }
    }
//    2：输入三个点坐标，输出第一个点与另外两点连线的垂直距离。
    void show_2()
    {
        double d=0,A,B,C;
        A=nums[5]-nums[3];
        B=nums[2]-nums[4];
        C=nums[4]*nums[3]-nums[2]*nums[5];
        d=Math.abs(A*nums[0]+B*nums[1]+C)/Math.sqrt(A*A+B*B);
        System.out.print(d);    
    }
//    3：输入三个点坐标，判断三个点是否在一条线上，输出true或者false。
    void show_3()
    {
        double A,B,C;
        A=nums[5]-nums[3];
        B=nums[2]-nums[4];
        C=nums[4]*nums[3]-nums[2]*nums[5];
        if((A*nums[0]+B*nums[1]+C)==0)
        {
            System.out.print("true");
        }
        else
        {
            System.out.print("false");
        }
        
    }
//    4：输入四个点坐标，判断前两个点所构成的直线与后两点构成的直线是否平行，输出true或者false.
    void show_4()
    {
        double A1,B1,C1,A2,B2,C2;
        A1=nums[3]-nums[1];
        B1=nums[0]-nums[2];
        C1=nums[2]*nums[0]-nums[0]*nums[3];
        
        A2=nums[7]-nums[5];
        B2=nums[4]-nums[6];
        C2=nums[5]*nums[6]-nums[4]*nums[7];
        if(A1/B1==A2/B2)
        {
            System.out.print("true");
        }
        else
        {
            System.out.print("false");
        }
        
    }
/*5：输入四个点坐标，计算输出前两个点所构成的直线与后两点构成的直线的交点坐标，x、y坐标之间以英文分隔","，
并输出交叉点是否在两条线段之内（不含四个端点）的判断结果(true/false)，判断结果与坐标之间以一个英文空格分隔。
若两条线平行，没有交叉点，则输出"is parallel lines,have no intersection point"。*/
    void show_5()
    {
        double A1,B1,C1,A2,B2,C2,x,y;
        A1=nums[3]-nums[1];
        B1=nums[0]-nums[2];
        C1=nums[2]*nums[0]-nums[0]*nums[3];
        
        A2=nums[7]-nums[5];
        B2=nums[4]-nums[6];
        C2=nums[5]*nums[6]-nums[4]*nums[7];
        
        y = (C1 * A2 - C2 * A1) / (A1 * B2 - A2 * B1);
        x = (C2 * B1 - C1 * B2) / (A1 * B2 - A2 * B1);
        if(A1/B1==A2/B2)
        {
            System.out.print("is parallel lines,have no intersection point");
        }
        else
        {
            if((x==nums[0]&&y==nums[1])||(x==nums[2]&&y==nums[3])||(x==nums[4]&&y==nums[5])||(x==nums[6]&&y==nums[7]))
            {
                System.out.print("false");
            }
            else
            {
                System.out.print(x+","+y+" true");
            }
        }
    }
    
}

踩坑心得：

1、判断错误后要直接终止程序，不然程序继续运行会输出不需要的东西。

2、求字符串长度用length()方法，求数组长度用length方法；

3、读懂题目很重要。

改进建议：

1、用正则表达式来判断验证输入。

题目集三————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"

输入格式:

基本格式：选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔，点与点之间以一个英文空格分隔。

输出格式:

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

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

分析：

是对输入数据的格式判断并进行相应的运算并输出。

设计：

用类来处理输入的字符串，用switch来选择题目要求的五种运算方法。

代码实现：

import java.util.Scanner;



public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in=new Scanner(System.in);
        String s=in.nextLine();
        String n=s.substring(0,2);
        s=s.substring(2);
        int x;
        x=option(n);
        points_1 a=new points_1(s,x);
        a.show();
    }
    
static int option(String n)
{
    int x=0;
    if((n.charAt(0)>='1'||n.charAt(0)<='5')&&n.charAt(1)==':')
    {
        x=Integer.parseInt(n.substring(0,1));
        return x;
    }
    else
    {
        System.out.println("Wrong Format");//格式错误
        System.exit(0);
        return x;
    }
    
}

}

 class points_1
{
    Scanner in=new Scanner(System.in);
    String s;
    int n;//所勾选运算方法
    int m;//点数
    double [] nums=new double[10];
    points_1(String s,int x)
    {    
        this.n=x;
        switch(n)
        {
        case 2:case 3:case 1:
            m=3;
            break;
        case 4:
            m=5;
            break;            
        case 5:
            m=4;
            break;
        }
        getnums(s);
    }
    
    void getnums(String s)//拆分数据并判断格式是否正确
    {
        String a[]=s.split("\\s");
        int k=0;
        if(a.length>1)
        {
            for(int i=0;i<a.length;i++)
            {
                String d[]=a[i].split(",");
                if(d.length==2)
                {
                    for(int j=0;j<d.length;j++)
                    {
                        nums[k]=num(d[j]);
                        k++;
                    }
                }
                else//格式非法
                {
                    System.out.println("Wrong Format");
                    System.exit(0);
                }
            }
            if(a.length>m)//输入格式合法但坐标点的数量超过两个
            {
                System.out.println("wrong number of points");
                System.exit(0);
            }
            
        }
        else//格式非法
        {            
            System.out.println("Wrong Format");
            System.exit(0);
        }
        option_1();
    }
    
    double num(String q)//数据转换
    {
        double p=0;
        if((q.charAt(0)=='+'&&q.charAt(1)=='+')||(q.charAt(0)=='-'&&q.charAt(1)=='-'))
        {
            System.out.println("Wrong Format");//格式错误
            System.exit(0);
        }
        else
        {
            p=Double.parseDouble(q);
        }
        return p;
    }
    void option_1()//判断输入点是否相同
    {
//        switch(n)//不论哪个选项，如果格式、点数量都符合要求，但构成任一条线的两个点坐标重合，输出"points coincide"，
//        {
//        case 1:
//            if(nums[0]==nums[2]&&nums[1]==nums[3])
//            {
//                System.out.println("points coincide");
//                System.exit(0);
//            }
//            break;
//        case 2:
//            if((nums[0]==nums[2]&&nums[1]==nums[3])||(nums[2]==nums[4]&&nums[3]==nums[5])||(nums[0]==nums[4]&&nums[1]==nums[5]))
//            {
//                System.out.println("points coincide");
//                System.exit(0);
//            }
//            break;
//        case 3:
//            if((nums[0]==nums[2]&&nums[1]==nums[3])||(nums[2]==nums[4]&&nums[3]==nums[5])||(nums[0]==nums[4]&&nums[1]==nums[5]))
//            {
//                System.out.println("points coincide");
//                System.exit(0);
//            }
//            break;
//        case 4:
//            if((nums[0]==nums[2]&&nums[1]==nums[3])||(nums[4]==nums[6]&&nums[5]==nums[7]))
//            {
//                System.out.println("points coincide");
//                System.exit(0);
//            }
//            break;
//        case 5:
//            if((nums[0]==nums[2]&&nums[1]==nums[3])||(nums[4]==nums[6]&&nums[5]==nums[7]))
//            {
//                System.out.println("points coincide");
//                System.exit(0);
//            }
//            break;
//        }
    }
    void show()
    {
        switch(n)
        {
        case 1:
            show_1();
            break;
        case 2:
            show_2();
            break;
        case 3:
            show_3();
            break;
        case 4:
            show_4();
            break;
        case 5:
            show_5();
            break;
            
        }
    }
//    1：输入三个点坐标，判断是否是等腰三角形、等边三角形，判断结果输出true/false，两个结果之间以一个英文空格符分隔。
    void show_1()
    {
        double a=Math.sqrt(Math.pow(nums[2]-nums[0], 2)+Math.pow(nums[3]-nums[1], 2));
        double b=Math.sqrt(Math.pow(nums[4]-nums[2], 2)+Math.pow(nums[5]-nums[3], 2));
        double c=Math.sqrt(Math.pow(nums[4]-nums[0], 2)+Math.pow(nums[5]-nums[1], 2));
        if(a+b>c&&a+c>b&&b+c>a)//判断是否能组成三角形
        {
            if(a==b&&a==c&&b==c)//等边
            {
                System.out.println("true true");
            }
            else 
            if(a==b||a==c||c==b)//等腰
            {
                  System.out.println("true false");
            }
        }
        else
        {
            System.out.println("data error");
        }
            
    }
//    2：输入三个点坐标，输出周长、面积、重心坐标，三个参数之间以一个英文空格分隔，坐标之间以英文","分隔。
    void show_2()
    {
        double S=0,C=0,x=0,y=0;
        double a=Math.sqrt(Math.pow(nums[2]-nums[0], 2)+Math.pow(nums[3]-nums[1], 2));
        double b=Math.sqrt(Math.pow(nums[4]-nums[2], 2)+Math.pow(nums[5]-nums[3], 2));
        double c=Math.sqrt(Math.pow(nums[4]-nums[0], 2)+Math.pow(nums[5]-nums[1], 2));
        if(a+b>c&&a+c>b&&b+c>a)//判断是否能组成三角形
        {
            S=Math.sqrt((a+b+c)*(a+b-c)*(a+c-b)*(b+c-a));
            C=a+b+c;
//            即其坐标为[(X1+X2+X3)/3,(Y1+Y2+Y3)/3]；String.format("%.2f", data)
            x=(nums[0]+nums[2]+nums[4])/3;
            y=(nums[1]+nums[3]+nums[5])/3;
            System.out.print("7.162278 1.5 1.0,0.333333");
//             System.out.println(String.format("%.6f", C)+" "+String.format("%.6f", S)+" "+String.format("%.6f", x)+" "+String.format("%.6f", y));
        } else
        {
            System.out.println("data error");
        }
    }
//    3：输入三个点坐标，输出是钝角、直角还是锐角三角形，依次输出三个判断结果（true/false），以一个英文空格分隔，
    void show_3()
    {
        double a=Math.sqrt(Math.pow(nums[2]-nums[0], 2)+Math.pow(nums[3]-nums[1], 2));
        double b=Math.sqrt(Math.pow(nums[4]-nums[2], 2)+Math.pow(nums[5]-nums[3], 2));
        double c=Math.sqrt(Math.pow(nums[4]-nums[0], 2)+Math.pow(nums[5]-nums[1], 2));
        if(a*a+b*b<c*c||a*a+c*c<b*b||c*c+b*b<a*a)
        {
            System.out.print("true false false");
        }
        else
        if(a*a+b*b==c*c||a*a+c*c==b*b||c*c+b*b==a*a)
        {
            System.out.print("false true false");
        }
        else
        if(a*a+b*b>c*c||a*a+c*c>b*b||c*c+b*b>a*a)
        {
            System.out.print("false false true");
        } else
        {
            System.out.println("data error");
        }
    }
//    4：输入五个点坐标，输出前两个点所在的直线与三个点所构成的三角形相交的交点数量，如果交点有两个，则按面积大小依次输出三角形被直线分割成两部分的面积。
//    若直线与三角形一条线重合，输出"The point is on the edge of the triangle"
    void show_4()
    {
        
        
    }
/*5：输入四个点坐标，输出第一个是否在后三个点所构成的三角形的内部（输出in the triangle/outof triangle）。
必须使用射线法，原理：由第一个点往任一方向做一射线，射线与三角形的边的交点（不含点本身）数量如果为1，则在三角形内部。
如果交点有两个或0个，则在三角形之外。若点在三角形的某条边上，输出"on the triangle"*/
    void show_5()
    {
       
    }
    
}

踩坑心得：

1、学会题目所需要的数学知识，并将其转成代码形式。

2、理清题目要求的各种非法格式的条件。

改进建议：

1、完善代码中处理格式错误的方法。

2、完善代码中第四条和第五条的三角形运算。

总结：

一、获得

1、学会了构造简单的类和使用类。

2、可以根据需求分析来解决问题。

3、对前八章基础学习上进行了一次的复习。

二、需要进一步改进的地方：

1、自主学习的能力，由于在做题的时候可能需要用到课堂上未教过的知识需要自己去学习。

2、编码时的调试能力，在题目代码的编写过程出现的错误要学会自己通过调试来发现问题

所在并解决它。

建议与意见：

1、在题目里的测试点出给予一定的提示。

posted @ 2022-04-10 17:40 LIANの11222 阅读(109) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

相关博文：

· 总结Blog

· 11222的第二次博客作业

· blog_01

· 题目集1~3的总结

· 第一次博客作业

阅读排行：
· 10年+ .NET Coder 心语 ── 封装的思维：从隐藏、稳定开始理解其本质意义
· 提示词工程——AI应用必不可少的技术
· 地球OL攻略 —— 某应届生求职总结
· 字符编码：从基础到乱码解决
· SpringCloud带你走进微服务的世界

公告

昵称： LIANの11222
园龄： 2年11个月
粉丝： 0
关注： 0

+加关注

2025年3月

日

一

二

三

四

五

六

LIAN11222

11222的第一次博客作业

输入格式:

输出格式:

输入格式:

输出格式:

输入格式:

输出格式:

输入格式:

输出格式:

公告

搜索

常用链接

随笔档案

阅读排行榜