对PTA题目集1~3的总结
一、作业总结
这几次的PTA作业主要考察我们对Java语言中的字符串的输入和输出、转换、有关它们的方法的运用和相关的一些运算，还有我们对题目需求的了解和书写代码的规范；其次还有强化我们对“类”的使用；当然还有我们对一些常见算法的了解。
作业的题量还是与它的难度大概成反比，但就结果而言，三次的PTA作业难度逐渐增高，第一次作业最多但是比较简单，第二次则是中规中矩，而第三次就是比较难了。在这里的难其实很大一部分是因为在提交后即使知道自己的测试点错了但是却不知道测试点是什么，这也就间接地提高了题目的难度。其次是题目要求的问题有些是我没有见过和听过的，以至于一见到它就不知道从何处下手，也不知道该用什么算法，在网上又找不到可以借鉴的方法（找到了也有些也是看不懂）。还有就是对一些方法的不熟也是一个痛点，翻书要时间，而且因为不知道写方法而自己去写代码去实现自己想要的功能也是有难度和要时间的。下面分别对一些作业做个简要分析。
二、作业分析
1、串口字符解析（题目集2的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
这道题给我们介绍了串口常用的通信协议——RS232，并以此为题基础，让我们编写程序，模拟串口接收处理程序，并且为了简单，题目告诉我们输入格式为由0、1组成的二进制数据流。例如：11110111010111111001001101111111011111111101111，并且假定有效数据是8位，奇偶校验位采用奇校验。首先我们看到这么长的数据流，应该不会去用“int”去输入，所以我们应该可以从它要检测每一个“0”和“1”和长度想到应该用“String”创建字符串，并且再用“toCharArray()”这个方法来将它转换成字符数组，这样才能更好去检测数据。
Scanner in=new Scanner (System.in);
String str=in.nextLine();
char [] num=str.toCharArray();
之后就是对输入的数据进行分析和检测，这里只需要用for循环来检查数据是否合法；还有进行数据流的输出，代码如下：
{
Scanner in=new Scanner (System.in);
String str=in.nextLine();
char [] num=str.toCharArray();
int n=num.length;
int ln=n/11+1;
int[] zero=new int [ln];
for(int i=0;i<ln;i++) {
zero[i]=-1;
}
if(n<11) {
System.out.println("null data");
}
else {
int flag=0;
for(int i=0;i<n;i++) {
if(num[i]=='0') {
flag=1;
break;
}
else {
flag=0;
}
}
if(flag==0) {
System.out.println("null data");
}
else {
int z=0;
int a=0;
while(a<n) {
if(num[a]=='0') {
flag=1;
zero[z]=a;
z++;
a=a+11;
}
else {
a++;
}
}
int m=0;
for(int i=0;i<zero.length;i++) {
if(zero[i]!=-1) {
m++;
}
}
for (int i=0;i<m;i++ ) {
int time=i;
int jy=zero[i]+9;
int js=zero[i]+10;
int js2=js+11;
int jyy=0;
if(js<n) {
for(int j=1;j<=9;j++) {
if(num[zero[i]+j]=='1') {
jyy++;
}
}
time++;
if(jyy%2==1) {
if(num[js]=='0') {
System.out.print(time+":validate error");
}
else {
System.out.print(time+":");
for(int j=1;j<=8;j++) {
System.out.print(num[zero[i]+j]);
}
}
}
else {
if(num[js]=='1') {
System.out.print(time+":parity check error");
}
else {
System.out.print(time+":validate error");
}
}
if(js2<n) {
System.out.println();
}
}
else {
break;
}
}
}
}
}
踩坑心得：这题要注意的是，题目中的奇偶校验是用前面的合法的数据相加再加上数据倒数第二位的奇偶校验来判断数据是否合格并输出，不然过不了样例6：
输入样例6:
两组数据，数据之间无空闲位。例如：
1110000000001100111000001输出样例6:
在这里给出相应的输出。例如：
1:00000000
2:01110000
如果只是检验它的奇偶校验为，那么输出的应该是：1:parity check error
2:parity check error改进建议：代码可以适当的简洁一些，判断数据是否合格可以定义不同的方法来实现，这样应该会好一些。
二、点线形系列1-计算两点之间的距离 （题目集3的7-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”。
这题的题目要求很简单，就是我们平常要算的两点之间的距离，虽说题目一目了然，但是对输入的数据要有很高的要求，只要输入的数据不符合坐标的形式，那就要程序报“"Wrong Format”，而且输入正确后也要注意坐标点的数量，超过了要求就会输出“wrong number of points”。在这里因为输入的数据中存在空格和逗号等字符，所以我们输入的时候也要选择字符串输入。再然后就是对数据的校验——是否有空格，逗号，小数点，加号和减号（而且不能同一个数里出现两个）的字符出现，接着好要注意空格和逗号的数量关系和位置关系，之后还要确定小数点后有没有数、整数位有没有出现只有两个零的情况等等，做好以上检验后就开始计算，我们可以用“split(" ")”这个方法来将我们输入的数组进行字符串按照空格分成两个坐标，再进行两次“split(",")”来获得两个坐标点x和y。之后再用“Double.parseDouble”来讲字符转换成double类型的x和y，最后再通过两点之间的距离公式(√（x1-x2）²+(y1-y2)²)来计算距离。代码如下：
校验代码：
import java.util.Scanner; public class Main
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
String Point = in.nextLine();
char[] point = Point.toCharArray();
int flag=1;
if(point.length<7) {
flag=0;
}
else {
flag=judge(point);
if(flag==1) {
for(int i=0;i<point.length-1;i++) {
if(point[i]=='+'||point[i]=='-') {
if(point[i+1]<'0'||point[i+1]>'9') {
flag=0;
break;
}
}
else if((point[i]<'0'||point[i]>'9')&&point[i]!=' '&&point[i]!=','&&point[i]!='.') {
flag=0;
break;
}
else {
continue;
}
if(flag==0) {
break;
}
}
}
flag= judge1(point);
}
if(flag==1) {
int dou=0;
for(int i=0;i<point.length;i++) {
if(point[i]==',') {
dou++;
}
}
if(dou>2) {
System.out.print("wrong number of points");
}
else if(dou==2) {
calculate(Point);
}
else {
System.out.print("Wrong Format");
}
}
else {
System.out.print("Wrong Format");
}
}
private static int judge1(char[] point) { int flag=1;
for(int i=1;i<point.length-1;i++) {
if(point[i]=='.') {
if(point[i+1]==' '||point[i+1]==',') {
if(point[i-1]>='0'&&point[i-1]<='9') {
flag=0;
break;
}
}
else if(point[i-1]==' '||point[i-1]==',') {
if(point[i+1]>='0'&&point[i+1]<='9') {
flag=0;
break;
}
}
}
}
if(flag==1) {
for(int i=1;i<point.length-1;i++) {
if(point[i]=='+'||point[i]=='-'||point[i]=='*'||point[i]=='/') {
if(point[i+1]>='0'&&point[i+1]<='9'&&point[i-1]>='0'&&point[i-1]<='9') {
flag=0;
}
}
}
}
for(int i=2;i<point.length;i++) {
if(point[i]=='.'&&point[i-1]=='0'&point[i-2]=='0') {
flag=0;
break;
}
}
return flag;
} private static int judge(char[] point) {
int flag=1;
int k=0;
int d=0;
int n=0;
int [][]num=new int[2][];
for(int i=0;i<point.length;i++) {
if(point[i]==' ') {
k++;
}
else if(point[i]==','){
d++;
}
else {
n++;
}
}
if(point[0]==' '||point[0]==','||k>n||d>n||k+d>n||d-k!=1||point[point.length-1]<'0'||point[point.length-1]>'9') {
flag=0;
}
else {
int k1=0;
int d1=0;
num[0]=new int[k];
num[1]=new int[d];
for(int i=0;i<point.length;i++) {
if(point[i]==' ') {
num[0][k1]=i;
k1++;
}
else if(point[i]==','){
num[1][d1]=i;
d1++;
}
}
int j=0;
while(j<k1) { if(Math.abs((num[1][j]+num[1][j+1])/2-num[0][j])!=1&&Math.abs((num[1][j]+num[1][j+1])/2-num[0][j])!=0) {
flag=0;
break;
}
j++;
}
} return flag;
}
}
计算代码：
private static void calculate(String Point) {
String [] p=Point.split(" ");
String P1=p[0];
String P2=p[1];
String [] xy1=P1.split(",");
String [] xy2=P2.split(",");
double x1=Double.parseDouble(xy1[0]);
double y1=Double.parseDouble(xy1[1]);
double x2=Double.parseDouble(xy2[0]);
double y2=Double.parseDouble(xy2[1]);
double L=Math.sqrt(Math.pow((x1-x2),2)+Math.pow((y1-y2),2));
System.out.print(L);
}
踩坑心得：比较一下本题的校验代码和计算代码，我可以发现其实这道题的难点是在于数据的校验上，写这道题要考虑很多种输入错误的格式，稍微不注意就会漏掉一些测试点，这也就是本题的唯一的难点。然后就是要记得并且不能写错。
改进建议：因为我自己这道题并没有过全部的测试点，所以还是建议自己重新再检查一遍自己校验的代码。然后对代码的建议就是把校验代码里的一些类似的检验情况整合在一起，也可以运用多个方法来进行检验，这样才能让代码看上去更加明了。
三、点线形系列2-线的计算（题目集3的7-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"，
输出格式:
见题目描述。
这道题可以说是题7-1的进阶版，由点的问题转到线的问题，而且出现了超过两个点乃至四个点的情况，并且一题出现了5个需求。在这里我使用了“类”来进行对这5个问题的计算。当然在计算之前也要有对输入数据的校验，还有对字符串的拆分，并且在“类”中用“switch”来根据不同的要求来写不同的算法求解。
代码如下：
“类”代码（因为之前的校验与上一题几乎差不多，只插入运算的代码）：
1 class Line{
2 String point;
3 int n;
4 int m;
5 int sum=0;
6 int Flag;
7 int flagxy;
8 double k;
9 double L;
10 double xj,yj;
11 double [][]xy=new double[4][2];
12 public Line(String[] Point1,int n1) {
13 this.point=Point1[1];
14 this.m=n1;
15 switch(n1) {
16 case 1: this.n=2;break;
17 case 2:
18 case 3: this.n=3;break;
19 case 4:
20 case 5: this.n=4;break;
21 }
22
23 }
24 public boolean judge1(String[] pointN, int m) {
25 char []pp=point.toCharArray();
26 for(int i=0;i<pp.length;i++) {
27 if(pp[i]==',') {
28 sum++;
29 }
30 }
31 if(sum!=this.n)
32 return false;
33 return true;
34
35 }
36 public void num() {
37 String [] p=point.split(" ");
38 String [] xy1=p[0].split(",");
39 String [] xy2=p[1].split(",");
40 xy[0][0]=Double.parseDouble(xy1[0]);
41 xy[0][1]=Double.parseDouble(xy1[1]);
42 xy[1][0]=Double.parseDouble(xy2[0]);
43 xy[1][1]=Double.parseDouble(xy2[1]);
44 switch(m) {
45 case 2:
46 case 3: {
47 String [] xy3=p[2].split(",");
48 xy[2][0]=Double.parseDouble(xy3[0]);
49 xy[2][1]=Double.parseDouble(xy3[1]);
50 }break;
51 case 4:
52 case 5: {
53 String [] xy3=p[2].split(",");
54 xy[2][0]=Double.parseDouble(xy3[0]);
55 xy[2][1]=Double.parseDouble(xy3[1]);
56 String [] xy4=p[3].split(",");
57 xy[3][0]=Double.parseDouble(xy4[0]);
58 xy[3][1]=Double.parseDouble(xy4[1]);
59 }break;
60 }
61 judge2();
62 }
63 public void judge2() {
64 for(int i=0;i<this.n-1;i++) {
65 if(xy[i][0]==xy[i+1][0]&&xy[i][1]==xy[i+1][1]) {
66 this.Flag=0;
67 break;
68 }
69 else {
70 this.Flag=1;
71 }
72 }
73 turn();
74 }
75 private void turn() {
76 if(this.Flag==1) {
77 calculate();
78 }
79 else {
80 System.out.print("points coincide");
81 }
82 }
83 private void calculate() {
84 switch(this.m) {
85 case 1: {
86 if(xy[0][0]==xy[1][0]) {
87 this.flagxy=0;
88 System.out.print("Slope does not exist");
89 }
90 else {
91 k=(xy[0][1]-xy[1][1])/(xy[0][0]-xy[1][0]);
92 System.out.print(this.k);
93 }
94 }break;
95 case 2: {
96 L=Math.abs((xy[1][1]-xy[2][1])*xy[0][0]+(xy[2][0]-xy[1][0])*xy[0][1]+xy[1][0]*xy[2][1]-xy[2][0]*xy[1][1]);
97 System.out.print(L);
98 }break;
99 case 3: {
100 if(((xy[0][1]-xy[1][1])*(xy[1][0]-xy[2][0]))==((xy[1][1]-xy[2][1])*(xy[0][0]-xy[1][0]))) {
101 System.out.print(true);
102 }
103 else {
104 System.out.print(false);
105 }
106 }break;
107 case 4: {
108 if(((xy[0][1]-xy[1][1])*(xy[2][0]-xy[3][0]))==((xy[2][1]-xy[3][1])*(xy[0][0]-xy[1][0]))) {
109 System.out.print(true);
110 }
111 else {
112 System.out.print(false);
113 }
114 }break;
115 case 5: {
116 double k1=0;
117 double k2=0;
118 double b1=0;
119 double b2=0;
120 if(xy[0][0]==xy[1][0]&&xy[2][0]==xy[3][0]) {
121 System.out.print("is parallel lines,have no intersection point");
122 }
123 else {
124 if(xy[0][0]==xy[1][0]) {
125 xj=xy[0][0];
126 k2=(xy[2][1]-xy[3][1])/(xy[2][0]-xy[3][0]);
127 b2=xy[2][1]-k2*xy[2][0];
128 yj=k2*xj+b2;
129 k1=k2-1;
130 }
131 else if(xy[2][0]==xy[3][0]) {
132 xj=xy[2][0];
133 k1=(xy[0][1]-xy[1][1])/(xy[0][0]-xy[1][0]);
134 b1=xy[0][1]-k1*xy[0][0];
135 yj=k1*xj+b1;
136 k2=k1-1;
137 }
138 else {
139 k1=(xy[0][1]-xy[1][1])/(xy[0][0]-xy[1][0]);
140 k2=(xy[2][1]-xy[3][1])/(xy[2][0]-xy[3][0]);
141 b1=xy[0][1]-k1*xy[0][0];
142 b2=xy[2][1]-k2*xy[2][0];
143 xj=(k1-k2)/(b2-b1);
144 yj=k1*xj+b1;
145 }
146 if(k1==k2) {
147 System.out.print("is parallel lines,have no intersection point");
148 }
149 else {
150 System.out.print(xj+","+yj+" ");
151 double a1=Math.max(xy[0][0],xy[1][0]);
152 double a2=Math.max(xy[0][1],xy[1][1]);
153 double a3=Math.max(xy[2][0],xy[3][0]);
154 double a4=Math.max(xy[2][1],xy[3][1]);
155 if(k1!=k2) {
156 if(xj<a1&&xj<a2) {
157 System.out.print(true);
158 }
159 else {
160 if(xj>=a3||yj>=a4) {
161 System.out.print(false);
162 }
163 else {
164 System.out.print(true);
165 }
166 }
167 }
168 }
169 }
170 }break;
171 }
172 }
173 }
踩坑心得：首先就是要理解题目，然后看清楚题目中每一个要求的输出结果，其次是对一些算法的熟悉；再者细节方面要注意两点重合和求一条线的斜率是要注意斜率不存在的情况，还有就是注意一个数除以0在程序中是不会报错而且是可以输出结果的，只是输出的结果会影响后续程序的运行；总的来说就是注意点线之间的一些数学关系，在写代码时要多加注意。
改进建议：改进的话，校验部分同上一题一样，但针对“类”的改进，提高“类”中不同方法的关联性，让它们更加清晰，可以先写一个含switch的方法来根据用户的输入去到另外五个分别解决对应需求的方法中，再在那五个方法中写好代码就行了，这样会让我们的“类”更加具有层次感，而不是向以上的代码一样五个运算都挤在一个方法中。
四、点线形系列3-三角形的计算（题目集的7-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"，
这道题也是上一题的进阶版，可以说第三次作业的题目是循序渐进的，由点到线再到面。这题又出现了更多的点，相应地字符串的分割也要更多了，难度也相应地增加了。 改题的代码几乎和第二题的几乎无异，就是多出来几个坐标点，还有“类”中的一些变量和方法也要相应地改变，而且方法中解决题目需求的算法逻辑更加难想到。代码开头仍是“String”来输入字符串数组，在进行合法性的判断，接着在创建的“类”中通过不同的首个字符来根据题目需求来解决问题。
代码如下（也是“类”的代码）：
1 class Line{
2 int n;
3 int m;
4 int sum;
5 String point;
6 double []x=new double[5];
7 double []y=new double[5];
8 public Line(String[] Point1,int n1) {
9 this.point=Point1[1];
10 this.m=n1;
11 switch(n1) {
12 case 1:
13 case 2:
14 case 3: this.n=3;break;
15 case 4: this.n=5;break;
16 case 5: this.n=4;break;
17 }
18
19 }
20
21 public void num() {
22 String [] p=point.split(" ");
23 String [] xy1=p[0].split(",");
24 String [] xy2=p[1].split(",");
25 String [] xy3=p[2].split(",");
26 x[0]=Double.parseDouble(xy1[0]);
27 y[0]=Double.parseDouble(xy1[1]);
28 x[1]=Double.parseDouble(xy2[0]);
29 y[1]=Double.parseDouble(xy2[1]);
30 x[2]=Double.parseDouble(xy3[0]);
31 y[2]=Double.parseDouble(xy3[1]);
32 x[2]=Double.parseDouble(xy3[0]);
33 y[2]=Double.parseDouble(xy3[1]);
34
35 switch(m) {
36 case 4:{
37 String [] xy4=p[3].split(",");
38 x[3]=Double.parseDouble(xy4[0]);
39 y[3]=Double.parseDouble(xy4[1]);
40 String [] xy5=p[3].split(",");
41 x[4]=Double.parseDouble(xy5[0]);
42 y[4]=Double.parseDouble(xy5[1]);
43 }break;
44 case 5:{
45 String [] xy4=p[3].split(",");
46 x[3]=Double.parseDouble(xy4[0]);
47 y[3]=Double.parseDouble(xy4[1]);
48 }break;
49 }
50 judge2();
51
52 }
53
54 private void judge2() {
55 int flag=0;
56 if(m==4) {
57 if(x[0]==x[1]&&y[0]==y[1]) {
58 flag=1;
59 System.out.print("points coincide");
60 }
61 }
62 if(flag==0) {
63 int n1=n-3;
64 if(x[n1]==x[n1+1]) {
65 if(x[n1+2]!=x[n1]) {
66 calculate();
67 }
68 }
69 else {
70 double k=(y[n1]-y[n1+1])/(x[n1]-x[n1+1]);
71 double b=y[n1]-k*x[n1];
72 if(k*x[n1+2]+b==y[n1+2]) {
73 show();
74 }
75 else {
76 calculate();
77 }
78 }
79 }
80 }
81 private void calculate() {
82 double l1=Math.sqrt(Math.pow(x[0]-x[1], 2)+Math.pow(y[0]-y[1], 2));
83 double l2=Math.sqrt(Math.pow(x[0]-x[2], 2)+Math.pow(y[0]-y[2], 2));
84 double l3=Math.sqrt(Math.pow(x[2]-x[1], 2)+Math.pow(y[2]-y[1], 2));
85 switch(m) {
86 case 1: {
87 if(l1==l2&&l1==l3&&l2==l3) {
88 System.out.print(false+" "+true);
89 }
90 else {
91 if(l1==l2||l1==l3||l2==l3) {
92 System.out.print(true+" "+false);
93 }
94 else {
95 System.out.print(false+" "+false);
96 }
97 }
98 }break;
99 case 2: {
100 double c=l1+l2+l3;
101 double s=c/2;
102 double area=Math.sqrt(s*(s-l1)*(s-l2)*(s-l3));
103 double xz=(x[0]+x[1]+x[2])/3;
104 double yz=(y[0]+y[1]+y[2])/3;
105 System.out.printf("%6f ",c);
106 System.out.printf("%6f ",area);
107 System.out.printf("%6f,%6f",xz,yz);
108 }break;
109 case 3:{
110 if(l1*l1+l2*l2-l3*l3<=1e-6||l1*l1+l3*l3-l2*l2<=1e-6||l3*l3+l2*l2-l1*l1<=1e-6) {
111 System.out.print("false,true,false");
112 }
113 else if(l1*l1+l2*l2-l3*l3>1e-6||l1*l1+l3*l3-l2*l2>1e-6||l3*l3+l2*l2-l1*l1>1e-6) {
114 System.out.print("false,false,true");
115 }
116 else {
117 System.out.print("true,false,false");
118 }
119 }break;
120 case 4:{
121 System.out.print(1);
122 for(int i=0;i<4;i++) {
123 if(x[0]==x[1]&&x[2]==x[3]) {
124 if(x[0]==x[2]||x[0]==x[3]||x[0]==x[4]) {
125 System.out.print("The point is on the edge of the triangle");
126 }
127 }
128 else {
129
130 }
131 }
132
133 }break;
134 case 5:{
135 System.out.print("in the triangle");
136 }break;
137 }
138 }
139
140 private void show() {
141 System.out.print("data error");
142 }
143
144 public boolean judge1(String[] point2, int n2) {
145 char []pp=point.toCharArray();
146 for(int i=0;i<pp.length;i++) {
147 if(pp[i]==',') {
148 sum++;
149 }
150 }
151 if(sum!=this.n)
152 return false;
153 return true;
154 }
155 }
踩坑心得：相较于数学计算上的求直角三角形用勾股定理，由于Java中的的数据范围并不是数学上意义的范围，所以在计算比较时应该不能有等号，而是让两条边的平方减去另一条边的平方的绝对值来小于一个比较小的数，例如1e-6,即0.0000006，不然那样的话就无法识别等腰直角三角形这种特殊的直角三角形。另外四舍五入的话，应该可以先对数据进行判定，再来根据判断结果输出是否四舍五入和保留位数。然后就是射线法，做之前应该先了解射线法怎么使用，再将其转化成Java语言，在进行求解。
改进建议：首先因该是把代码补齐（因为时间原因代码的功能并未完全实现），其次的改进就是同上一题一样，再加上可以把“类”中每一个满足需求的方法中的一些判断也可以写成单独写成一个方法。
三、总结
总的来说，通过本阶段三次题目集，让我学会了很多关于Java的知识，包括巩固了在课堂上老师讲过的东西还有自己在书上翻到的一些程序用法；还让自己主动地上网查资料，见识了专业之外的一些知识。然后让自己知道了一些不足之处——对一些常用方法的不熟悉、对题目的不理解（也就是孤陋寡闻）、获取知识的效率不高、敲代码的速度不快、写的代码不能高效地实现功能、而且代码不够简介，十分冗杂等等，这些都是我以后要加以改正的点，要做到灵活地使用自身所学，而且还要善于在网上获取新知识。另外针对于作业这方面，我希望出题老师可以把测试点写得详细一点，我们可以“对症下药”，能知道自己的作业哪里错了需要改正，而不是在自己写的代码上盲目死磕，这样也能够节省一些时间（一点拙见，望采纳）。
对PTA题目集1~3的总结的更多相关文章
- PTA题目集7-9总结
PTA题目集7-9总结 一.前言 题目集七:该题集为轮到图形卡片排序游戏题,主要考查的知识点有类的继承,ArrayList泛型的使用,Compabale接口的运用,多态的使用方法以及接口的应用,难度较 ...
- PTA题目集4-6总结
PTA题目集4-6总结 一:前言 在题集4-6中,所考查的主要知识点有正则表达式,类与类之间的调用,类的聚合,继承,封装,接口与多态,三种排序方法如选择排序,冒泡排序,插入排序,ArrayList,s ...
- PTA题目集总结
PTA题目集1-3总结 一:前言 我认为题目集一的有八个题目,题量可能稍微有点多,但是题型较为简单,基本为入门题:题集二有五道题,题量适度,难度也适中:题集三虽然只有三道题,但是难度却骤然提升,前两题 ...
- 皓远的第一次博客作业(pta题目集——1-3）
题目集总结: 前言: 一. 知识点运用: ① Java入门的基础语法(循环,判断,字符串,数组等等),Java的基础类运用,类与对象关系调用,类间关系(聚合). ② 引(类与对象): 对象 ...
- PTA数据结构与算法题目集(中文) 7-43字符串关键字的散列映射 (25 分)
PTA数据结构与算法题目集(中文) 7-43字符串关键字的散列映射 (25 分) 7-43 字符串关键字的散列映射 (25 分) 给定一系列由大写英文字母组成的字符串关键字和素数P,用移位法定义 ...
- PTA数据结构与算法题目集(中文) 7-42整型关键字的散列映射 (25 分)
PTA数据结构与算法题目集(中文) 7-42整型关键字的散列映射 (25 分) 7-42 整型关键字的散列映射 (25 分) 给定一系列整型关键字和素数P,用除留余数法定义的散列函数将关键字映射 ...
- PTA数据结构与算法题目集(中文) 7-41PAT排名汇总 (25 分)
PTA数据结构与算法题目集(中文) 7-41PAT排名汇总 (25 分) 7-41 PAT排名汇总 (25 分) 计算机程序设计能力考试(Programming Ability Test,简称P ...
- PTA数据结构与算法题目集(中文) 7-40奥运排行榜 (25 分)
PTA数据结构与算法题目集(中文) 7-40奥运排行榜 (25 分) 7-40 奥运排行榜 (25 分) 每年奥运会各大媒体都会公布一个排行榜,但是细心的读者发现,不同国家的排行榜略有不同.比如 ...
- PTA数据结构与算法题目集(中文) 7-39魔法优惠券 (25 分)
PTA数据结构与算法题目集(中文) 7-39魔法优惠券 (25 分) 7-39 魔法优惠券 (25 分) 在火星上有个魔法商店,提供魔法优惠券.每个优惠劵上印有一个整数面值K,表示若你在购买某商 ...
- PTA数据结构与算法题目集(中文) 7-38寻找大富翁 (25 分)
PTA数据结构与算法题目集(中文) 7-38寻找大富翁 (25 分) 7-38 寻找大富翁 (25 分) 胡润研究院的调查显示,截至2017年底,中国个人资产超过1亿元的高净值人群达15万人.假 ...
随机推荐
- 1、Spring源码环境搭建
本文目的 完成Spring Framework5.x的源码构建 准备 官网:Spring Framework 使用5.x版本源码包构建 项目管理工具 gradle(没学过的先去找资料学习) 说明 Sp ...
- 百万级数据excel导出功能如何实现？
前言 最近我做过一个MySQL百万级别数据的excel导出功能,已经正常上线使用了. 这个功能挺有意思的,里面需要注意的细节还真不少,现在拿出来跟大家分享一下,希望对你会有所帮助. 原始需求:用户在U ...
- Docker命令的自动补齐
Docker命令的自动补齐 背景 在linux下输入命令或文件都是可以自动补齐的,这个特性极大的提高了我们的效率,多数情况下我们很少用命令参数的自动补齐. 但对docker git这类参数特别多的命令 ...
- Docker修改已有容器的端口映射
Docker修改已有容器的端口映射 背景 拉取了jenkins的镜像,启动容器的时候端口就映射了8080,但这个演示环境要用到jenkins node,其中默认的代理端口是50000.漏了,就想着能否 ...
- CAS 悲观锁 乐观锁
前面的偏向锁,轻量级锁,重量级锁都是悲观锁, 都会认为必须要对操作对象进行互斥访问,不然就会产生异常, 所以线程只供一个线程使用,阻塞其他线程,是悲观的 在某些情况下,同步的耗时远大于线程切换的时间, ...
- 力扣---45. 跳跃游戏 II
给定一个长度为 n 的 0 索引整数数组 nums.初始位置为 nums[0].每个元素 nums[i] 表示从索引 i 向前跳转的最大长度.换句话说,如果你在 nums[i] 处,你可以跳转到任意 ...
- 【OpenWrt】N1刷机过程及旁路由设置（通用）
最近买了个N1盒子,从源系统刷到OpenWrt,总结一下整体过程,大部分都来源于网络教程和自己实践,如有错误欢迎指出! N1盒子刷机 固件准备 最著名的应该是F大的吧,原贴地址:[2023-2-14] ...
- 【已解决】SQL2012启动时报错：cannot find one or more cpmponents
下载Microsoft Visual Studio 2010 Shell(Isolate)-CHS安装即可 下载地址:Visual Studio 独立 Shell 下载及安装:点击同意许可,选择vs2 ...
- Vue中v-model与:value的区别
v-model不可以加其他值 <input type="text" v-model="curAmount"> :value可以加 单位 <in ...
- Postgresql WAL日志浅析
一.预写日志(WAL) 预写式日志(Write Ahead Log,WAL)是保证数据完整性的一种标准方法.简单来说,WAL的中心概念是数据文件(存储着表和索引)的修改必须在这些动作被日志记录之后才被 ...