题目集1~3总结Blog - ooooqqq

题目集1~3总结Blog

一、前言：

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

1、知识点

题目集1考察了Java基本基础知识，比如 if,while,for循环的使用。

题目集2考察了数据类型之间的转换、字符串的使用方法。

题目集3考察了类与方法及字符串的使用。

2、题量

题目集1题目多，量不大。

题目集2题少，量中等。

题目集3题少，量大。

3、难度

题目集1难度低，都是基础知识。

题目集2较题目集1难度大一些，需花一些时间。

题目集3的难度骤然上升，需写代码多且测试点多而细，对我来说非常不容易。

二、设计与分析

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

核心源码：

for(int i=0;i<a.length();i++)
{
if(a.charAt(i)!='1')
{
p=1;
}
}
if(p==0)
{
System.out.print("null data");
return;
}

if(a.length()<11)
{
System.out.print("null data");
return;
}
for(b=0;b<a.length()-10;b++)
{
if(a.charAt(b) == '0')
{
System.out.print(f+":");
f++;
if(a.charAt(b+10)=='0')
{
System.out.println("validate error");
b+=10;
continue;
}
int m=0;
for(d=b+1;d<b+9;d++)
{
if(a.charAt(d)=='1')
m++;
}
if(m%2==0)
{
if(a.charAt(b+9)=='0')
{
System.out.println("parity check error");
b+=10;
continue;
}
}
else
{
if(a.charAt(b+9)=='1')
{
System.out.println("parity check error");
b+=10;
continue;
}
}
for(d=b+1;d<b+9;d++)
System.out.print(a.charAt(d));
System.out.print("\n");
b+=10;
}
}
}
}

分析：

代码先判断数据不足11位或者输入数据全1没有起始位，之后按照题目规则检查字符串（这里需要使用到字符串的字符下标和各种字符串方法知识），然后把符合规则的数据输出，不符合规则的数据打印出错误。

类图：

分析报表：

解释：

由类图知我仅使用了一个类，一个方法。

由报表知平均方法数目过多，最大圈复杂度过大，平均深度过大，平均圈复杂度过大，其他正常。

心得：

代码圈复杂度高，应该使用多个类和方法使圈复杂度变小，使其可读性变高。

本题题目较长较难懂，需要仔细理解清楚题目意思，理解之后会发现挺好写的。

2、题目集3 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

核心源码：

for(String i:b)
{
c = i.split(",");
for(String j:c)
{
if(!j.matches("^[+-]?(0|(0\\.\\d+)?|[1-9][0-9]*(\\.\\d+)?)$"))
{
System.out.println("Wrong Format");
return ;
}
}
}

if(b.length!=2)
{
System.out.println("wrong number of points");
return ;
}

if(q==e&&w==r)
{
System.out.println("Wrong Format");
return ;
}
double z = Math.sqrt(Math.pow((q-e),2)+Math.pow((w-r),2));
System.out.print(z);
}
}

分析：

主要通过正则表达式来判断格式是否错误，用公式计算两点之间的距离。

类图：

分析报表：

解释：

由类图知我仅使用了一个类，一个方法。

由报表知平均方法数目过多，平均圈复杂度过大，其他正常。

心得：

平均圈复杂度过大，可使用多个类和方法使圈复杂度变小，可读性变高。

本题使用正则表达式比较好，需要掌握正则表达式，有正则表达式来判断格式是否错误之后，问题就好解决了。

3、题目集3 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"，

输出格式:

见题目描述。

核心源码：

void one(String s)
{
if(a.length!=2)
{
System.out.print("wrong number of points");
return;
}

if(p1.length !=2||p2.length !=2)
{
System.out.print("Wrong Format");
return;
}
if((truth(p1[0]))||(truth(p1[1]))||(truth(p2[0]))||(truth(p2[1])))
{
System.out.print("Wrong Format");
return;
}

if(a[0].equals(a[1]))
{
System.out.print("points coincide");
return;
}

if(x1==x2)
System.out.print("Slope does not exist");
else
{
double b =(y2 - y1) / (x2 - x1);
System.out.print(b);
}

}
void two(String s)
{
if(s1.length!=3)
{
System.out.print("wrong number of points");
return ;
}

if(p1.length!=2||p2.length!=2||p3.length!=2)
{
System.out.print("Wrong Format");
return;
}
if((truth(p1[0]))||(truth(p1[1]))||(truth(p2[0]))||(truth(p2[1]))||(truth(p3[0]))||(truth(p3[1])))
{
System.out.print("Wrong Format");
return;
}

if(s1[0].equals(s1[1])|| s1[1].equals(s1[2])||s1[0].equals(s1[2]))
{
System.out.print("points coincide");
return;
}

double b = Math.abs(((y3 - y2) * (x1 - x2) - (x3 - x2) * (y1 - y2))/ Math.sqrt(Math.pow((y2 - y3), 2) + Math.pow((x2 - x3), 2)));
System.out.print(b) ;
}

void three(String s)
{
if(s1.length<3)
{
System.out.print("wrong number of points");
return;
}

if (p1.length != 2 || p2.length != 2 || p3.length != 2)
{
System.out.print("Wrong Format");
return;
}
if((truth(p1[0]))||(truth(p1[1]))||(truth(p2[0]))||(truth(p2[1]))||(truth(p3[0]))||(truth(p3[1])))
{
System.out.print("Wrong Format");
return;
}
if(s1.length>3)
{
System.out.print("wrong number of points");
return;
}
if (Math.abs((y2- y1) / (x2 - x1)) == Math.abs((y0 - y1) / (x0 - x1)))
System.out.print("true");
else
System.out.print("false");

}

void four(String s)
{
if(s1.length!=4)
{
System.out.print("wrong number of points");
return ;
}

if(p1.length != 2 || p2.length != 2 || p3.length != 2 ||p4.length != 2)
{
System.out.print("Wrong Format");
return;
}
if((truth(p1[0]))||(truth(p1[1]))||(truth(p2[0]))||(truth(p2[1]))||(truth(p3[0]))||(truth(p3[1]))||(truth(p4[0]))||(truth(p4[1])))
{
System.out.print("Wrong Format");
return;
}

if (s1[0].equals(s1[1]) ||s1[2].equals(s1[3]))
{
System.out.print("points coincide");
return;
}
if ( (y3 - y2) / (x3 - x2) == (y1 - y0) / (x1 - x0))
System.out.print("true");
if ((y3 - y2) / (x3 - x2) != (y1 - y0) / (x1 - x0))
System.out.print("false");
}

void five(String s)
{

if(s1.length!=4)
{
System.out.print("wrong number of points");
return ;
}

if(p1.length != 2 || p2.length != 2 || p3.length != 2 ||p4.length != 2)
{
System.out.print("Wrong Format");
return;
}
if((truth(p1[0]))||(truth(p1[1]))||(truth(p2[0]))||(truth(p2[1]))||(truth(p3[0]))||(truth(p3[1]))||(truth(p4[0]))||(truth(p4[1])))
{
System.out.print("Wrong Format");
return;
}

if (s1[0].equals(s1[1]) ||s1[2].equals(s1[3]))
{
System.out.print("points coincide");
return;
}

if((x1==x2&&y1==y2)||(x3==x4&&y4==y3))
{
System.out.print("points coincide");
}
else
{
double h=Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
double l=Math.sqrt((x3-x4)*(x3-x4)+(y3-y4)*(y3-y4));
double k1 = (y2 - y1) / (x2 - x1);
double k2 = (y4 - y3) / (x4 - x3);
if((x1 == x2 && y1 == y2) || (x3 == x4 && y3 == y4))
System.out.println("points coincide");
else if(x1 == x2 && x3 == x4)
System.out.println("is parallel lines,have no intersection point");
else if(k1 == k2)
System.out.println("is parallel lines,have no intersection point");
else
{
double x=(y3*x4*x2-y4*x3*x2-y3*x4*x1+y4*x3*x1-y1*x2*x4+y2*x1*x4+y1*x2*x3-y2*x1*x3)/(x4*y2-x4*y1-x3*y2+x3*y1-x2*y4+x2*y3+x1*y4-x1*y3);
double y=(-y3*x4*y2+y4*x3*y2+y3*x4*y1-y4*x3*y1+y1*x2*y4-y1*x2*y3-y2*x1*y4+y2*x1*y3)/(y4*x2-y4*x1-y3*x2+x1*y3-y2*x4+y2*x3+y1*x4-y1*x3);
double a1=Math.sqrt((x-x2)*(x-x2)+(y-y2)*(y-y2));
double a2=Math.sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1));
double a3=Math.sqrt((x-x3)*(x-x3)+(y-y3)*(y-y3));
double a4=Math.sqrt((x-x4)*(x-x4)+(y-y4)*(y-y4));
if(((a1+a2)-h<=0.0001&&x!=x1&&x!=x2)||((a3+a4)-l)<=0.0001&&x!=x3&&x!=x4)
flag = true;
else
flag = false;
System.out.println((float)x+","+(float)y+" "+flag);
}
}

分析：

先将输入的坐标转化为x1,x2,x3,x4,y1,y2,y3,y4.
选项1斜率直接公式计算(y2 - y1) / (x2 - x1)。

选项2在草稿纸上演算好式子代入得Math.abs(((y3 - y2) * (x1 - x2) - (x3 - x2) * (y1 - y2))/ Math.sqrt(Math.pow((y2 - y3), 2) + Math.pow((x2 - x3), 2)))。

选项3判断斜率是否相等 if (Math.abs((y2- y1) / (x2 - x1)) == Math.abs((y0 - y1) / (x0 - x1)))。

选项4和选项3一样判断斜率是否相等if ( (y3 - y2) / (x3 - x2) == (y1 - y0) / (x1 - x0))。

选项5算出表达式代入

double x=(y3*x4*x2-y4*x3*x2-y3*x4*x1+y4*x3*x1-y1*x2*x4+y2*x1*x4+y1*x2*x3-y2*x1*x3)/(x4*y2-x4*y1-x3*y2+x3*y1-x2*y4+x2*y3+x1*y4-x1*y3);
double y=(-y3*x4*y2+y4*x3*y2+y3*x4*y1-y4*x3*y1+y1*x2*y4-y1*x2*y3-y2*x1*y4+y2*x1*y3)/(y4*x2-y4*x1-y3*x2+x1*y3-y2*x4+y2*x3+y1*x4-y1*x3);

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

double a2=Math.sqrt((x-x1)*(x-x1)+(y-y1)*(y-y1));
double a3=Math.sqrt((x-x3)*(x-x3)+(y-y3)*(y-y3));
double a4=Math.sqrt((x-x4)*(x-x4)+(y-y4)*(y-y4));
if(((a1+a2)-h<=0.0001&&x!=x1&&x!=x2)||((a3+a4)-l)<=0.0001&&x!=x3&&x!=x4)

类图：

分析报表：

解释：

由类图知我仅使用了两个类，共使用7个方法。

由报表知平均方法数目过多，平均圈复杂度过大，最大圈复杂度过大，其他正常。

心得：

平均圈复杂度过大，应该多使用类和方法使圈复杂度变小，可读性变高。

我写的代码没有分很多类和方法，导致代码太长不够清晰。本题如果稳扎稳打，尽量多使用类和方法封装就可以使代码更加简洁易读好写。

4、题目集3 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"，

核心源码：

//主类
public class Main
{
public static void main(String[] args)
{
Sth a = new Sth();
a.Sh();
}
}

// 点类
class point
{
double x = 0;
double y = 0;
int num1 = 0;
String str1 ,str2;

private boolean ifInt(String str)
{
if ( str == null || "".equals(str))
return false;

Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
return pattern.matcher(str).matches();
}

private boolean iffloat(String str)// 是否为浮点数
{
str1 = str.substring(0 , num1 );
str2 = str.substring(num1 + 1);

if((ifDouble(str1)||ifInt(str1))&&(ifDouble(str2)||ifInt(str2)))
return true;
else
return false;
}

private boolean ifDouble(String str)//数据是否符合要求
{
if ( str == null || "".equals(str))
return false;

Pattern pattern = Pattern.compile("^[-\\+]?\\d*[.]\\d+$");
return pattern.matcher(str).matches();
}
private boolean ifdouhao(String str)
{
int n = 0;
char[] c=str.toCharArray();
for(int i = 0; i < c.length; i++)
{
if(c[i] == ',')
{
num1 = i;
n++;
if(n > 1)
return false;
}
}
return true;
}
public void jiancha(String s)
{
if(ifdouhao(s))
{
if(iffloat(s))
{
x = Double.parseDouble(str1);
y = Double.parseDouble(str2);
}
else
System.out.print("data error");
}
else
System.out.print("data error");
}
}

class Sth// 点线运算类
{
int a = 0;
int b = 1;
String st1;
String st2;
String st3;
String st4;
String st5;
point s1 = new point();
point s2 = new point();
point s3 = new point();
point s4 = new point();
point s5 = new point();

point q1 = new point();
point q2 = new point();
point q3 = new point();

double k(point a, point b)//计算两点斜率
{
double x = (a.y - b.y) / (a.x - b.x);
return x;
}

Boolean ifline(point a, point b, double x, double y)//点是否在线段内
{
double xmax = Math.max(a.x, b.x);
double xmin = Math.min(a.x, b.x);
double ymax = Math.max(a.y, b.y);
double ymin = Math.min(a.y, b.y);
if ((x < xmax && x > xmin) || (y < ymax && y > ymin))
return true;
else
return false;
}

void Sh()
{
Scanner input = new Scanner(System.in);
String s = input.nextLine();

if (!tru(s))//是否合法
{
System.out.print("Wrong Format");
return;
}
a = (int) s.charAt(0) - 48;
String ss = s.substring(2);

b = huoNum(ss);

if (!SNum(a, b))
{
System.out.print("wrong number of points");
return;
}
cutstring(ss);
switch (a)
{
case 1: one();break;
case 2: two();break;
case 3: three();break;
case 4: four();break;
case 5: five();break;
}
}

double meas(point s1, point s2, point s3)//三角形面积
{
double a = distance(s1, s2);
double b = distance(s2, s3);
double c = distance(s3, s1);

double p = (a + b + c) / 2;
double s = Math.sqrt(p * (p - a) * (p - b) * (p - c));

return s;
}

Boolean tru(String s) //是否合法
{
if (s.matches("[1-5][:](([+|-]?[0-9]+([\\.][0-9]+|[0-9]*)[,][+|-]?[0-9]+([\\.][0-9]+|[0-9]*)[\\s]{1})+([+|-]?[0-9]+([\\.][0-9]+|[0-9]*)[,][+|-]?[0-9]+([\\.][0-9]+|[0-9]*))+)"))
return true;
else
return false;
}

boolean SNum(int a, int b)
{
if ((a == 1 && b == 3) || (a == 2 && b == 3) || (a == 3 && b == 3) || (a == 4 && b == 5) || (a == 5 && b == 4))
return true;
else
return false;
}

int huoNum(String s) //坐标个数
{
int o = 1;
for (int i = 0; i < s.length(); i++)
{
if (s.charAt(i) == ' ')
o++;
}
return o;
}

double distance(point s1, point s2)//计算两点间距离
{
double x = Math.sqrt((s1.x - s2.x) * (s1.x - s2.x) + (s1.y - s2.y) * (s1.y - s2.y));
return x;
}

Boolean jiaodian(point s1, point s2, point s3, point s4, point s)//求两直线交点
{
if (s1.x == s2.x && s3.x == s4.x)
return false;

double k1 = k(s1, s2);
double k2 = k(s3, s4);

if (k1 == k2)
return false;

double x = (s3.y * s4.x * s2.x - s4.y * s3.x * s2.x - s3.y * s4.x * s1.x + s4.y * s3.x * s1.x - s1.y * s2.x * s4.x + s2.y * s1.x * s4.x + s1.y * s2.x * s3.x - s2.y * s1.x * s3.x) / (s4.x * s2.y - s4.x * s1.y - s3.x * s2.y + s3.x * s1.y - s2.x * s4.y + s2.x * s3.y + s1.x * s4.y - s1.x * s3.y);
double y = ((-s3.y * s4.x * s2.y + s4.y * s3.x * s2.y + s3.y * s4.x * s1.y - s4.y * s3.x * s1.y + s1.y * s2.x * s4.y - s1.y * s2.x * s3.y - s2.y * s1.x * s4.y + s2.y * s1.x * s3.y) / (s4.y * s2.x - s4.y * s1.x - s3.y * s2.x + s1.x * s3.y - s2.y * s4.x + s2.y * s3.x + s1.y * s4.x - s1.y * s3.x));

if (ifline(s3, s4, x, y))
{
s.x = x;
s.y = y;
return true;
}
else
return false;
}

分析：

本题难度较大，需要尽可能地使用多的类和方法使代码清晰，比如求斜率的方法，判断是否为三角形的方法等等。

要将每一个大问题拆成很多个小问题，再将小问题的解决封装在方法里，在大问题的解决中直接调用，这样使大问题的解决代码清晰简洁思路明晰。

本题第四选项和第五选项对数学能力有一定的要求，需要有一定的数学能力才能完成。

类图：

分析报表：

解释：

由类图知我使用了三个类，共使用24个方法。

由报表知平均方法数目过多，其他正常。

心得：

我的代码平均方法数目过多。本题很难，需要稳扎稳打，尽量多使用类和方法封装可以使代码更加简洁易读，使解题思路更加清晰。

我一开始并没有用很多类和方法，导致在后面选项越来越难，代码越来越多越来越杂，写得越来越累。上课听到老师说要多使用类和方法，我尝试性地试了试发现挺好用的，分类后代码变得清晰起来，不再混乱了，多使用类和方法好处真的很大。多使用类和方法对较大量代码的工程来说非常好，可减小圈复杂度，使代码更加清晰可读。