JAVA pta 前三次大作业回顾与分析

一、前言：总结三次题目集的知识点、题量、难度等情况

今年初次接触java，通过这三次大作业的练习，我对java有了一定的认识，相比于其他编程语言来说，java更复杂，要求也更严谨，需要掌握的知识也更多。

第一次pta：

知识点：数值类型转换，字符串类型，选择结构，循环结构，逻辑操作符

题量：9 道题

难度：一般

第二次pta：

知识点：字符串类型，选择结构，循环结构，逻辑操作符

题量：3道题

难度：稍微复杂起来。

第三次pta：

知识点：正则表达式，选择结构，循环结构，逻辑操作符，字符串类型，从字符串中获取字符，类型转换，类和对象的建立

题量：3道题

难度：突然变得困难还有点复杂。

（2）设计与分析：

第二次pta

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

代码如下：

 1 import java.util.Scanner;

 2 public class Main{

 3     public static void main(String[] args){

 4         Scanner in=new Scanner(System.in);

 5         String s=in.nextLine();

 6         if(s.length()<11){  //长度不足11

 7             System.out.print("null data");

 8             return;

 9         }

10     int begin=0,count=1,sum=0,i=0;

11       boolean flag=false,flag1=false,flag2=false;

12         for(begin=0;begin<s.length()-10;begin++){

13             if(s.charAt(begin)=='0'){

14                 flag2=true ;

15                 //判断起始位是否为1

16                 System.out.print(count+":");

17                 count++;

18             if(s.charAt(begin+10)=='0'){//判断结束位是否为1

19                 flag1=false;

20                 System.out.println("validate error");

21                 begin=begin+10;

22             }

23                 else{

24                     flag1=true;

25                 sum=0;

26                 for(i=begin+1;i<begin+9;i++){   //判断奇偶校验位是否为奇校验

27                     if(s.charAt(i)=='1'){

28                         sum++;    //sum计算1的数量

29                     }

30                 }

31                 if(sum%2==0){

32                    if(s.charAt(begin+9)=='1')

33                         flag=true;

34                     else

35                         flag=false;

36                 }

37                     else {

38                         if(s.charAt(begin+9)=='0')

39                         flag=true;

40                        else

41                             flag=false;

42                 }

43                  //   flag=false;

44                     if(flag==false&&flag1==true)

45                         System.out.println("parity check error");

46                     //    return;

47        /*  if(flag==false&&flag1==false){    //结束符和奇偶校验位都不符合

48              System.out.print("validate error");

49           }*/

50                     if(flag==true&&flag1==true){

51                       for(i=begin+1;i<begin+9;i++){

52                           System.out.print(s.charAt(i));

53                       }

54                         System.out.print("\n");

55                     }

56

57             begin=begin+10;

58               }

59             }

60         }

61        if(flag2==false)

62        {

63             System.out.print("null data");

64             //return;

65         }

66    }

67 }

SourceMonitor的分析图如下：

分析如下：

通过分析，代码中写了较多的if，else判断，导致该代码的环复杂度和平均深度都比较高。并且只使用了一个类来实现题目要求，导致代码复用性比较低。

采坑心得：

由于一开始对奇偶校验位的概念不是很熟悉，在判断奇偶校验位的时候那个测试点过不去，导致后面的测试点也有问题，我一开始以为是后面的问题，后来查了查才发现是判断奇偶位那里出现错误。

改进建议：一开始我的思路是边判断边输出，但是到后面我发现先考虑完所有情况，最后放在一起判断然后输出比较整洁，代码的可读性也会提高。

第三次pta作业

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

代码如下：

 1 import java.util.Scanner;

 2 public class Main{

 3     public static void main(String[] args){

 4         Scanner in=new Scanner(System.in);

 5         String input =in.nextLine();  //可以接收空格键

 6         String point[]=input.split(" ");//分割符

 7         String num[]=null;

 8         int cot=0;

 9         for(String i:point){

10             num=i.split(",");

11             for(String j:num){  //正则表达式

12                 if(!j.matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$")){

13                    System.out.print("Wrong Format");

14                    System.exit(0);

15                 }

16             }

17         }

18         if(point.length!=2){

19           System.out.print("wrong number of points");

20           System.exit(0);

21         }

22         num = point[0].split(",");    //把输入的转成数字

23         double x1= Double.valueOf(num[0]);

24         double y1= Double.valueOf(num[1]);

25         num = point[1].split(",");

26         double x2= Double.valueOf(num[0]);

27         double y2= Double.valueOf(num[1]);

28        if(x1==x2&&y1==y2){

29             System.out.print("Wrong Format");

30             return;

31         }

32       System.out.print(Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2)));

33         in.close();

34     }

35 }

SourceMonitor的分析图如下：

分析如下：

这道题在这三道题里面可以算是最简单的一个，只需要在判断完非法输入之后用两点间的距离公式计算并输出就可以了。由于代码比较简单，所以复杂度不是很高。

采坑心得：

　　　对于正则表达式的运用不熟练，以至于判断非法输入的时候磕磕绊绊，然后试着去编写多次才成功，还有就是输出的时候，没有注意Wrong Format的w的大小写，导致最后一个测试点一直过不去！！！细心还是很重要的！！！

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"，

输出格式:

见题目描述。

代码如下：

  1 import java.util.Scanner;

  2 public class Main{

  3     public static void main(String[] args){

  4       Scanner in=new Scanner(System.in);

  5         String str=in.nextLine();

  6         int action=str.charAt(0)-48;

  7

  8         String[] tokens=str.split(" ");

  9         int jige=tokens.length;

 10         for(int i=0;i<jige;i++)

 11         {

 12             if(i==0)

 13             {

 14                 if(!tokens[i].matches("^[1-5][:](([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?)),([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))\\s?)$"))

 15                 {

 16                     System.out.print("Wrong Format");return;

 17                  }

 18             }

 19             else

 20             {

 21                 if(!tokens[i].matches("^(([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?)),([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))\\s?)$"))

 22                 {

 23                     System.out.print("Wrong Format");return;

 24                 }

 25             }

 26         }

 27

 28         if((action==1&&jige!=2)||(action==2&&jige!=3)||(action==3&&jige!=3)||(action==4&&jige!=4)||(action==5&&jige!=4))

 29         {

 30             System.out.print("wrong number of points");return;

 31         }

 32

 33         if(action==1)

 34         {

 35            double[] pointe=new double[4];

 36            String [] s=str.split(":");

 37            String [] s1=s[1].split(" ");

 38            String [] A=s1[0].split(",");

 39            String [] B=s1[1].split(",");

 40            double x1,y1,x2,y2;

 41             x1=Double.parseDouble(A[0]);

 42             y1=Double.parseDouble(A[1]);

 43             x2=Double.parseDouble(B[0]);

 44             y2=Double.parseDouble(B[1]);

 45              double k;

 46         /* if(point.length!=2)

 47          {

 48           System.out.print("wrong number of points");

 49         }*/

 50             if(x1==x2&&y1==y2) //两条线重合

 51             {

 52                 System.out.print("points coincide");

 53             }

 54             else if((x1-x2)==0&&(y1-y2)!=0)   //垂直于x轴

 55             {

 56                 System.out.println("Slope does not exist");

 57             }

 58             else

 59             {

 60                 k=(y2-y1)/(x2-x1);

 61                 System.out.println(k);

 62             }

 63         }

 64         if(action==2)

 65         {

 66            double[] pointe=new double[4];

 67            String [] s=str.split(":");

 68            String [] s1=s[1].split(" ");

 69            String [] A=s1[0].split(",");

 70            String [] B=s1[1].split(",");

 71            String [] C=s1[2].split(",");

 72            double x1,y1,x2,y2,x3,y3;

 73             x1=Double.parseDouble(A[0]);

 74             y1=Double.parseDouble(A[1]);

 75             x2=Double.parseDouble(B[0]);

 76             y2=Double.parseDouble(B[1]);

 77             x3=Double.parseDouble(C[0]);

 78             y3=Double.parseDouble(C[1]);

 79

 80              if(x2==x3&&y2==y3) //BC重合

 81              {

 82                System.out.print("points coincide");return;

 83              }

 84

 85             double d;

 86             if(x2==x3)//斜率不存在

 87                 d=(Math.abs(x1-x2));

 88             else

 89             {

 90                 double k=(y3-y2)/(x3-x2);

 91                 double b=y3-k*x3;

 92                 d=(Math.abs(k*x1-y1+b))/((Math.sqrt(k*k+1)));

 93             }

 94             System.out.print(d);

 95

 96         }

 97

 98         if(action==3)

 99         {

100            String [] s=str.split(":");

101            String [] s1=s[1].split(" ");

102            String [] A=s1[0].split(",");

103            String [] B=s1[1].split(",");

104            String [] C=s1[2].split(",");

105            double x1,y1,x2,y2,x3,y3;

106             x1=Double.parseDouble(A[0]);

107             y1=Double.parseDouble(A[1]);

108             x2=Double.parseDouble(B[0]);

109             y2=Double.parseDouble(B[1]);

110             x3=Double.parseDouble(C[0]);

111             y3=Double.parseDouble(C[1]);

112             double k1=(y2-y1)/(x2-x1);

113             double k2=(y3-y2)/(x3-x2);

114              if(x1==x2&&y1==y2) //两条线重合

115             {

116                 System.out.print("points coincide");return;

117             }

118             if(k1==k2)

119             {

120                 System.out.println("true");

121             }

122             else

123             {

124                 System.out.println("false");

125             }

126         }

127         if(action==4)

128         {

129            String [] s=str.split(":");

130            String [] s1=s[1].split(" ");

131            String [] A=s1[0].split(",");

132            String [] B=s1[1].split(",");

133            String [] C=s1[2].split(",");

134            String [] D=s1[3].split(",");

135            double x1,y1,x2,y2,x3,y3,x4,y4;

136             x1=Double.parseDouble(A[0]);

137             y1=Double.parseDouble(A[1]);

138             x2=Double.parseDouble(B[0]);

139             y2=Double.parseDouble(B[1]);

140             x3=Double.parseDouble(C[0]);

141             y3=Double.parseDouble(C[1]);

142             x4=Double.parseDouble(D[0]);

143             y4=Double.parseDouble(D[1]);

144             double k1=(y2-y1)/(x2-x1);

145             double k2=(y4-y3)/(x4-x3);

146              if((x1==x2&&y1==y2)||(x3==x4&&y3==y4)) //两条线重合

147             {

148                 System.out.print("points coincide");return;

149             }

150

151             if(k1==k2)   //两点构成的直线是否平行

152             {

153                 System.out.println("true");

154             }

155            else

156             {

157                System.out.println("false");

158             }

159         }

160         if(action==5)

161         {

162             String [] s=str.split(":");

163            String [] s1=s[1].split(" ");

164            String [] A=s1[0].split(",");

165            String [] B=s1[1].split(",");

166            String [] C=s1[2].split(",");

167            String [] D=s1[3].split(",");

168            double x1,y1,x2,y2,x3,y3,x4,y4;

169             x1=Double.parseDouble(A[0]);

170             y1=Double.parseDouble(A[1]);

171             x2=Double.parseDouble(B[0]);

172             y2=Double.parseDouble(B[1]);

173             x3=Double.parseDouble(C[0]);

174             y3=Double.parseDouble(C[1]);

175             x4=Double.parseDouble(D[0]);

176             y4=Double.parseDouble(D[1]);

177

178             double x,y;//交点坐标

179

180             if((x1==x2&&y1==y2)||(x3==x4&&y3==y4)) //AB重合和CD重合

181             {

182                 System.out.print("points coincide");return;

183             }

184

185             if(x1==x2&&x3==x4)

186             {

187                 System.out.print("is parallel lines,have no intersection point");return;

188             }

189             else if(x1==x2&&x3!=x4)

190             {

191                 double k2=(y4-y3)/(x4-x3);

192                 double b2=y3-k2*x3;

193                 x=x1;

194                 y=k2*x1+b2;

195                 x=Math.round(x*1000000)/(double)1000000;

196                 y=Math.round(y*1000000)/(double)1000000;

197                 System.out.print(x+","+y);

198             }

199             else if(x1!=x2&&x3==x4)

200             {

201                 double k1=(y2-y1)/(x2-x1);

202                 double b1=y1-k1*x1;

203                 x=x3;

204                 y=k1*x3+b1;

205                 x=Math.round(x*1000000)/(double)1000000;

206                 y=Math.round(y*1000000)/(double)1000000;

207                 System.out.print(x+","+y);

208             }

209             else//斜率都存在

210             {

211                 double k1=(y2-y1)/(x2-x1);

212                 double b1=y1-k1*x1;

213                 double k2=(y4-y3)/(x4-x3);

214                 double b2=y3-k2*x3;

215                 if(k1==k2)

216                 {

217                     System.out.print("is parallel lines,have no intersection point");return;

218                 }

219                 x=(b2-b1)/(k1-k2);

220                 y=k1*(b2-b1)/(k1-k2)+b1;

221                 x=Math.round(x*1000000)/(double)1000000;

222                 y=Math.round(y*1000000)/(double)1000000;

223                 System.out.print(x+","+y);

224             }

225

226             if((x==x1&&y==y1)||(x==x2&&y==y2)||(x==x3&&y==y3)||(x==x4&&y==y4))

227             {

228                 System.out.print(" false");return;

229             }

230

231             double ab=Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));

232             double ap=Math.sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1));

233             double bp=Math.sqrt((x2-x)*(x2-x)+(y2-y)*(y2-y));

234

235             double cd=Math.sqrt((x4-x3)*(x4-x3)+(y4-y3)*(y4-y3));

236             double cp=Math.sqrt((x-x3)*(x-x3)+(y-y3)*(y-y3));

237             double dp=Math.sqrt((x4-x)*(x4-x)+(y4-y)*(y4-y));

238

239             if((ap+bp-ab<0.0000001)||(cp+dp-cd<0.0000001))

240             {

241                 System.out.print(" true");

242             }

243             else

244                 System.out.print(" false");

245         }

246

247     }

248 }

SourceMonitor的分析图如下：

分析如下：由于在代码中对坐标的定义重复使用较高，以至于增加了代码的复杂度，使得代码变得比较长，

踩坑心得：在计算点的数量和非法输入格式的时候考虑不周全，导致测试点过不去，去找了同学帮忙才知道问题所在。还有计算坐标的时候，由于用到了除法，没有考虑到精度的问题，有很多时候某个选项的部分样例通过了, 然后有一两个样例过不去，后来发现之后才明白。

改进建议：应该多创建几个类，把重复使用的代码放在一个类里面，需要用的时候直接调就可以了，这样使得代码变短，降低了复杂度，提高了代码的可读性。

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"

代码如下：

import java.util.Scanner;

public class Main{

    public static void main(String[] args){

        Scanner in=new Scanner(System.in);

        String str=in.nextLine();

        int action=str.charAt(0)-48;

        //System.out.print(action);

        int cnt=0;

        String[] tokens=str.split(" ");

        int jige=tokens.length;

        for(int i=0;i<jige;i++)

        {

            if(i==0)

            {

                if(!tokens[i].matches("^[1-5][:](([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?)),([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))\\s?)$"))

                {

                    System.out.print("Wrong Format");return;

                 }

            }

            else

            {

                if(!tokens[i].matches("^(([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?)),([+-]?(0|(0\\.\\d+)|[1-9][0-9]*(\\.\\d+)?))\\s?)$"))

                {

                    System.out.print("Wrong Format");return;

                }

            }

        }

        if((action==1&&jige!=3)||(action==2&&jige!=3)||(action==3&&jige!=3)||(action==4&&jige!=5)||(action==5&&jige!=4))

        {

            System.out.print("wrong number of points");return;

        }

        if(action==1)

        {

            String [] s=str.split(":| |,");

            double x1,y1,x2,y2,x3,y3;

            x1=Double.parseDouble(s[1]);

            y1=Double.parseDouble(s[2]);

            x2=Double.parseDouble(s[3]);

            y2=Double.parseDouble(s[4]);

            x3=Double.parseDouble(s[5]);

            y3=Double.parseDouble(s[6]);

            //用Double.parseDouble()是把括号里面内容变成double类型的。

             //其中括号中的参数必须是String类型，否则转换会报错。

            double len1,len2,len3;

            len1=Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));

            len2=Math.sqrt((x3-x1)*(x3-x1)+(y3-y1)*(y3-y1));

            len3=Math.sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));

            if((len1+len2<=len3&&len3>len1&&len3>len1)||(len1+len3<=len2&&len2>len1&&len2>len1)||(len3+len2<=len1&&len1>len3&&len1>len3))

            {

                System.out.print("data error");return;

            }

            if((len1==len2)||(len1==len3)||(len2==len3))

            {

                System.out.print("true");//等腰

            }

            else

            {

                 System.out.print(" false");

            }

            if(len1==len2&&len1==len3&&len2==len3)

            {

                 System.out.print("true");//等边

            }

            else

            {

                System.out.print(" false");

            } 

        }

        if(action==2)

        {

            String [] s=str.split(":| |,");

            double x1,y1,x2,y2,x3,y3;

            x1=Double.parseDouble(s[1]);

            y1=Double.parseDouble(s[2]);

            x2=Double.parseDouble(s[3]);

            y2=Double.parseDouble(s[4]);

            x3=Double.parseDouble(s[5]);

            y3=Double.parseDouble(s[6]);

            double len1,len2,len3;

            len1=Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));

            len2=Math.sqrt((x3-x1)*(x3-x1)+(y3-y1)*(y3-y1));

            len3=Math.sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));

            if((len1+len2<=len3&&len3>len1&&len3>len1)||(len1+len3<=len2&&len2>len1&&len2>len1)||(len3+len2<=len1&&len1>len3&&len1>len3))

            {

                System.out.print("data error");return;

            }

            double c=len1+len2+len3;//计算周长

            double p=c/2;

            double S=Math.sqrt(p*(p-len1)*(p-len2)*(p-len3));

            double gx=(x1+x2+x3)/3;

            double gy=(y1+y2+y3)/3;  //重心坐标

            System.out.print(Math.round(c*1000000)/(double)1000000+" ");

            System.out.print(Math.round(S*1000000)/(double)1000000+" ");

            System.out.print(Math.round(gx*1000000)/(double)1000000+",");

            System.out.print(Math.round(gy*1000000)/(double)1000000);

        }

        if(action==3)

        {

            String [] s=str.split(":| |,");

            double x1,y1,x2,y2,x3,y3;

            x1=Double.parseDouble(s[1]);

            y1=Double.parseDouble(s[2]);

            x2=Double.parseDouble(s[3]);

            y2=Double.parseDouble(s[4]);

            x3=Double.parseDouble(s[5]);

            y3=Double.parseDouble(s[6]);

            double len1,len2,len3;

            len1=Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));

            len2=Math.sqrt((x3-x1)*(x3-x1)+(y3-y1)*(y3-y1));

            len3=Math.sqrt((x3-x2)*(x3-x2)+(y3-y2)*(y3-y2));

            if((len1+len2<=len3&&len3>len1&&len3>len1)||(len1+len3<=len2&&len2>len1&&len2>len1)||(len3+len2<=len1&&len1>len3&&len1>len3))

            {

                System.out.print("data error");return;

            }

            double cosa=(len1*len1+len2*len2-len3*len3)/(2*len1*len2);

            double cosb=(len2*len2+len3*len3-len1*len1)/(2*len2*len3);

            double cosc=(len1*len1+len3*len3-len2*len2)/(2*len1*len3);

            if(Math.abs(cosa)<0.000000001||Math.abs(cosb)<0.000000001||Math.abs(cosc)<0.000000001)

            {

                System.out.print("false true false");

            }

            else if(cosa>0&&cosb>0&&cosc>0)

            {

                System.out.print("false false true");

            }

            else

            {

                 System.out.print("true false false");

            }

        }

        if(action==4)

        {

            String [] s=str.split(":| |,");

            double x1,y1,x2,y2,x3,y3,x4,y4,x5,y5;

            x1=Double.parseDouble(s[1]);

            y1=Double.parseDouble(s[2]);

            x2=Double.parseDouble(s[3]);

            y2=Double.parseDouble(s[4]);

            x3=Double.parseDouble(s[5]);

            y3=Double.parseDouble(s[6]);

            x4=Double.parseDouble(s[7]);

            y4=Double.parseDouble(s[8]);

            x5=Double.parseDouble(s[9]);

            y5=Double.parseDouble(s[10]);

            if(x1==x2&&y1==y2) //AB重合

            {

                System.out.print("points coincide");return;

            }

            double a1=y2-y1;

            double b1=x1-x2;

            double c1=x2*y1-x1*y2;

            double a2=y4-y3;

            double b2=x3-x4;

            double c2=x4*y3-x3*y4;

            double a3=y5-y3;

            double b3=x3-x5;

            double c3=x5*y3-x3*y5;

            double a4=y5-y4;

            double b4=x4-x5;

            double c4=x5*y4-x4*y5;

            /*

            if((x3==x4&&x3==x5)||(x3==x4&&x4==x5||(x3==x5&&x4==x5)))

                System.out.print("data error");

            else if(a1/b1==a2/b2||a2/b2==a3/b3||a1/b1==a3/b3)

            {

               System.out.print("data error"); return;

            }

            */

            double len1,len2,len3,len4;

            len1=Math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));

            len2=Math.sqrt((x3-x4)*(x3-x4)+(y3-y4)*(y3-y4));

            len3=Math.sqrt((x3-x5)*(x3-x5)+(y3-y5)*(y3-y5));

            len4=Math.sqrt((x5-x4)*(x5-x4)+(y5-y4)*(y5-y4));

            //if((len3+len2<=len4&&len4>=len3&&len4>=len2)||(len2+len4<=len3&&len3>=len2&&len3>=len4)||(len3+len4<=len2&&len2>=len3&&len2>=len4))

            int w=0;

            if((len3+len2>len4&&len4>=len3&&len4>=len2)||(len2+len4>len3&&len3>=len2&&len3>=len4)||(len3+len4>len2&&len2>=len3&&len2>=len4))

            {

                w=1;

            }

            else

            {

                System.out.print("data error");return;

            }

            double x6,y6,x7,y7,x8,y8;

            int num=0;

            int flag1=0;

            int flag2=0;

            int flag3=0;

            //len1len2

            if(b1==b2)

            {

               num=num;

            }

            else if(b1!=0&&b2!=0&&(a1/b1==a2/b2))//平行

            {

                num=num;

            }

            else

            {

                 x6=(b1*c2-b2*c1)/(a1*b2-a2*b1);

                 y6=(a2*c1-a1*c2)/(a1*b2-a2*b1);

                 x6=Math.round(x6*1000000)/(double)1000000;

                 y6=Math.round(y6*1000000)/(double)1000000;

                 double oc=Math.sqrt((x6-x3)*(x6-x3)+(y6-y3)*(y6-y3));

                 double od=Math.sqrt((x4-x6)*(x4-x6)+(y4-y6)*(y2-y6));

                 if(oc+od-len2<0.000000001)

                 {

                     num++;flag1=1;

                 }

            }

            //len1len3

            if(b1==b3)

            {

               num=num;

            }

            else if(b1!=0&&b3!=0&&(a1/b1==a3/b3))//平行

            {

                num=num;

            }

            else

            {

                 x6=(b1*c2-b2*c1)/(a1*b2-a2*b1);

                 y6=(a2*c1-a1*c2)/(a1*b2-a2*b1);

                 x6=Math.round(x6*1000000)/(double)1000000;

                 y6=Math.round(y6*1000000)/(double)1000000;

                 x7=(b1*c3-b3*c1)/(a1*b3-a3*b1);

                 y7=(a3*c1-a1*c3)/(a1*b3-a3*b1);

                 x7=Math.round(x7*1000000)/(double)1000000;

                 y7=Math.round(y7*1000000)/(double)1000000;

                 if(flag1==1&&x6==x7&&y6==y7)

                 {

                     num=num;

                 }

                else

                {

                    double pc=Math.sqrt((x7-x3)*(x7-x3)+(y7-y3)*(y7-y3));

                    double pe=Math.sqrt((x5-x7)*(x5-x7)+(y5-y7)*(y5-y7));

                    if(pc+pe-len3<0.000000001)

                    {

                        num++;flag2=1;

                    }

                }

            }

            //len1len4

            if(b1==b4)

            {

               num=num;

            }

            else if(b1!=0&&b4!=0&&(a1/b1==a4/b4))//平行

            {

                num=num;

            }

            else

            {

                  x6=(b1*c2-b2*c1)/(a1*b2-a2*b1);

                 y6=(a2*c1-a1*c2)/(a1*b2-a2*b1);

                 x6=Math.round(x6*1000000)/(double)1000000;

                 y6=Math.round(y6*1000000)/(double)1000000;

                 x7=(b1*c3-b3*c1)/(a1*b3-a3*b1);

                 y7=(a3*c1-a1*c3)/(a1*b3-a3*b1);

                 x7=Math.round(x7*1000000)/(double)1000000;

                 y7=Math.round(y7*1000000)/(double)1000000;

                 x8=(b1*c4-b4*c1)/(a1*b4-a4*b1);

                 y8=(a4*c1-a1*c4)/(a1*b4-a4*b1);

                 x8=Math.round(x8*1000000)/(double)1000000;

                 y8=Math.round(y8*1000000)/(double)1000000;

                 if((flag1==1&&x8==x6&&y8==y6)||(flag2==1&&x8==x7&&y8==y7))

                 {

                     num=num;

                 }

                else

                {

                    double qd=Math.sqrt((x8-x4)*(x8-x4)+(y8-y4)*(y8-y4));

                 double qe=Math.sqrt((x5-x8)*(x5-x8)+(y5-y8)*(y5-y8));

                 if(qd+qe-len4<0.000000001)

                 {

                     num++;flag3=1;

                 }

                }

            }

            System.out.print(num);

                x6=(b1*c2-b2*c1)/(a1*b2-a2*b1);

                 y6=(a2*c1-a1*c2)/(a1*b2-a2*b1);

                 x6=Math.round(x6*1000000)/(double)1000000;

                 y6=Math.round(y6*1000000)/(double)1000000;

                 x7=(b1*c3-b3*c1)/(a1*b3-a3*b1);

                 y7=(a3*c1-a1*c3)/(a1*b3-a3*b1);

                 x7=Math.round(x7*1000000)/(double)1000000;

                 y7=Math.round(y7*1000000)/(double)1000000;

                 x8=(b1*c4-b4*c1)/(a1*b4-a4*b1);

                 y8=(a4*c1-a1*c4)/(a1*b4-a4*b1);

                 x8=Math.round(x8*1000000)/(double)1000000;

                 y8=Math.round(y8*1000000)/(double)1000000;

             double op=Math.sqrt((x7-x6)*(x7-x6)+(y7-y6)*(y7-y6));

             double oq=Math.sqrt((x8-x6)*(x8-x6)+(y8-y6)*(y8-y6));

             double pq=Math.sqrt((x7-x8)*(x7-x8)+(y7-y8)*(y7-y8));

            double z1=(len2+len3+len4)/2;

            double S=Math.sqrt(z1*(z1-len2)*(z1-len3)*(z1-len4));

            if(num==2)

            {

                if(flag1==1&&flag2==1)

                {

                    double oc=Math.sqrt((x6-x3)*(x6-x3)+(y6-y3)*(y6-y3));

                    double od=Math.sqrt((x4-x6)*(x4-x6)+(y4-y6)*(y2-y6));

                    double pc=Math.sqrt((x7-x3)*(x7-x3)+(y7-y3)*(y7-y3));

                    double Z=(oc+pc+op)/2;

                    double S1=Math.sqrt(Z*(Z-oc)*(Z-pc)*(Z-op));

                    if(S>S1)

                    {

                        System.out.print(" "+Math.round(S1*1000000)/(double)1000000);

                        System.out.print(" "+Math.round(S*1000000)/(double)1000000);

                    }

                    else

                    {

                        System.out.print(" "+Math.round(S*1000000)/(double)1000000);

                        System.out.print(" "+Math.round(S1*1000000)/(double)1000000);

                    }

                }

                else if(flag1==1&&flag3==1)

                {

                    double qd=Math.sqrt((x8-x4)*(x8-x4)+(y8-y4)*(y8-y4));

                    double oc=Math.sqrt((x6-x3)*(x6-x3)+(y6-y3)*(y6-y3));

                    double od=Math.sqrt((x4-x6)*(x4-x6)+(y4-y6)*(y2-y6));

                    double Z=(od+qd+oq)/2;

                    double S1=Math.sqrt(Z*(Z-od)*(Z-qd)*(Z-oq));

                    if(S>S1)

                    {

                        System.out.print(" "+Math.round(S1*1000000)/(double)1000000);

                        System.out.print(" "+Math.round(S*1000000)/(double)1000000);

                    }

                    else

                    {

                        System.out.print(" "+Math.round(S*1000000)/(double)1000000);

                        System.out.print(" "+Math.round(S1*1000000)/(double)1000000);

                    }

                }

                else if(flag2==1&&flag3==1)

                {

                    double qe=Math.sqrt((x5-x8)*(x5-x8)+(y5-y8)*(y5-y8));

                    double pe=Math.sqrt((x5-x7)*(x5-x7)+(y5-y7)*(y5-y7));

                    double Z=(qe+pe+pq)/2;

                    double S1=Math.sqrt(Z*(Z-qe)*(Z-pe)*(Z-pq));

                    if(S>S1)

                    {

                        System.out.print(" "+Math.round(S1*1000000)/(double)1000000);

                        System.out.print(" "+Math.round(S*1000000)/(double)1000000);

                    }

                    else

                    {

                        System.out.print(" "+Math.round(S*1000000)/(double)1000000);

                        System.out.print(" "+Math.round(S1*1000000)/(double)1000000);

                    }

                }

            }

        }

        if(action==5)

        {

             String [] s=str.split(":| |,");

            double x1,y1,x2,y2,x3,y3,x4,y4;

            x1=Double.parseDouble(s[1]);

            y1=Double.parseDouble(s[2]);

            x2=Double.parseDouble(s[3]);

            y2=Double.parseDouble(s[4]);

            x3=Double.parseDouble(s[5]);

            y3=Double.parseDouble(s[6]);

            x4=Double.parseDouble(s[5]);

            System.out.print("in the triangle");

        }

    }

}

SourceMonitor的分析图如下：

分析如下：这道题和第二道题的大致思路一样，由于两道题使用的方法差不多，因为这道题的要求更多，所以重复使用的代码更多，导致它的复杂性更高。

踩坑心得：在判断三角形形状的时候，我用的是余弦定理算出cos角来与直角比较，在没有考虑误差的时候，它的判断在有些样例下是错误的，所以需要给它一点误差。

在后面的计算中，精度问题也是一个需要考虑进去的大问题，四舍五入会答案错误。

改进建议：这道题是没有完全对的，在第五个点的时候因为计算和方法的问题，导致还有些测试点没有过。我觉得应该多使用类，把一些计算分别放在类里面，这样代码的可读性更高，复杂度也会更低。

三、三次作业大总结

这学期学习java到现在，通过这三次pta的作业编写，我发现前两次题目集相对来说比较容易一点，考察知识点大多数都是Java 的if-else语句，switch语句，输入输出的格式检验，数组的操作，string函等等。到第三次作业时，作业的难度有了一个很大的提升，所需要的的知识点也多了起来，我开始在网上学习所需要的的知识点，比如怎么分类，如何定义类，关键字的使用，Java的工具类函数，提高了代码的质量和效率空间，还有一些算法，比如：线与线的交点，判断用射线法点是否在三角形内，都是比较好的算法。通过这几次作业也发现了自己的好多不足，许多算法都不了解，虽然学习面对对象已经一个多月了，带面对过程的理念还是根深蒂固，解决问题的时候还是想着怎么输入输出，而不是先想着怎么分类，类的属性，类的方法，所以还是要加强面对对象理念，对进行相关的思考和训练。在课堂上老师也是很注重对我们面对对象理念的培养，经常要求我们设计类以此来强化我们对类的理解。java是一门比较复杂的编程语言，需要花费更多的精力和时间去钻研它，在以后的作业和学习中我会认真努力去了解和掌握。

改进建议：

巴特西

JAVA pta 前三次大作业回顾与分析

输入格式:

输出格式:

输入格式:

输出格式:

输入格式:

输出格式:

最新文章

热门文章