PTA前三次大作业总结
PTA前三次大作业总结
一.PTA三次大作业题目集的前言
1.第一次题目集
第一次大作业的主要特点是题量偏多，但难度较低。7-1 身体质量指数（BMI）测算考查的是对输出的判断。7-2 长度质量计量单位换算需要注意的是最后输出要将double转换为float型。7-3 奇数求和需要判断输出的数中的奇数并相加。7-4 房产税费计算2022稍微较复杂，需要理解各种费用的计算方法，并最后输出结果时将double转为float型。7-5 游戏角色选择较为简单，主要考查的是将各种结果输出。7-6 学号识别需要弄清楚不同位置的数字代表的含义，并学会用charAt( )获得相应位置的字符。7-8 巴比伦法求平方根近似值需仔细理解题目的意思。7-9 二进制数值提取主要考查循环。7-7 判断三角形类型需要用Math.abs(a*a+b*b-c*c)<0.00001来判断是否为直角三角形。
2.第二次题目集
第二次大作业题量较少，只有三道题，但难度较第一次提升了许多，整体上是对字符串的考查，相关知识如：字符串输入：String number = input.next( ),字符的获取如：charAt( ),特定位置的字符串的获取如：substring( )。7-1 字母-数字转换需要注意的是不能用“=”直接比较两字符串是否相等，而应使用compareto( )进行比较。7-2 串口字符解析比较难，占据的分数也比较多。需要读懂题目的意思，同时还需要了解奇偶校验的相关知识。7-3 String的格式判断与内容提取判断输入是否正确，若不正确就输出Wrong Format,若正确则提取特定两个班级202017班、202061班同学的学号后四位输出。
3.第三次大作业
第三次大作业难度相对于前两次提升了不少。其中测试点数不胜数，也许多较为难找到。7-1 点线形系列1-计算两点之间的距离难度主要在于排除各种错误的输入。7-2 点线形系列2-线的计算与7-3 点线形系列3-三角形的计算测试点很多。其中，测试点的测试范围广，测试内容细，还难以知道测试点测试的具体内容。
二.设计与分析
（1）1.7-1 身体质量指数（BMI）测算
体重是反映和衡量一个人健康状况的重要标志之一，过胖和过瘦都不利于健康，BMI（身体质量指数）计算方法：体重（以千克为单位）除以身高（以米为单位）的平方。
中国成人正常的BMI应在18.5-24之间，如果小于18.5为体重不足，如果大于等于24为超重，大于等于28为肥胖。请编写程序，测算身体状态。
输入格式:
两个数值：体重（以千克为单位），身高(以米为单位），数值间以空格分隔。例如：65.5 1.75。
注意：体重的世界纪录是727公斤，身高的世界纪录是2.72米。输入数据上限不得超过纪录，下限不得小于等于0；
输出格式:
输入数值超出范围 ：输出“input out of range”。例如：-2 3或者125 5。
BMI小于18.5 ：输出“thin”。
BMI大于等于18.5小于24 ：输出“fit”。
BMI大于等于24小于28 ：输出“overweight”。
BMII大于等于28 ：输出“fat”。
输入样例0:
在这里给出一组输入。例如：
-2 8
输出样例0:
在这里给出相应的输出。例如：
input out of range
输入样例1:
在这里给出一组输入。例如：
70 1.75
输出样例1:
在这里给出相应的输出。例如：
fit
1
2 import java.util.Scanner;
3 public class Main{
4 public static void main(String[] args){
5 Scanner input = new Scanner(System.in);
6 //System.out.print("weight height");
7 double weight = input.nextDouble();
8 double height = input.nextDouble();
9 if(weight<=0||weight>727||height<=0||height>2.72)
10 System.out.println("input out of range");
11 else{
12 double bmi=0.0;
13 bmi = 1.0*weight/(height * height);
14 if(bmi<18.5)
15 System.out.println("thin");
16 else if(bmi>=18.5&&bmi<24)
17 System.out.println("fit");
18 else if(bmi>=24&&bmi<28)
19 System.out.println("overweight");
20 else
21 System.out.println("fat");
22 }
23 }
24 }
总结：这道题较为简单，题目需要对输入的身高体重进行计算，并拿结果与标准进行比较，最后输出相应的标准。但由上图可见，复杂度较高，因此下次写代码时不仅要考
虑把题目完成，还应考虑尽量降低代码的复杂度。
长度、质量的计量有多重不同的计算体系，有标准的国际单位制：千克与米，也有各个国家自己的计量方法如：磅、英寸；1磅等于0.45359237千克，1英寸等于
0.0254米，请编写程序实现国际单位制与英制之间的换算。
输入格式:
两个浮点数，以空格分隔，第一个是质量（以千克为单位）、第二个是长度（以米为单位）。例如：0.45359237 0.0254。
输出格式:
两个浮点数，以空格分隔，第一个是质量（以磅为单位）、第二个是长度（以英寸为单位）。例如：1.0 1.0。
输入样例:
在这里给出一组输入。例如：
0.45359237 0.0254
输出样例:
在这里给出相应的输出。例如：
1.0 1.0 1 import java.util.Scanner;
2 public class Main{
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 double weight = input.nextDouble();
6 double height = input.nextDouble();
7 final double KILOGRAMS_PER_POUND = 0.45359237;
8 final double METERS_PRE_INCH = 0.0254;
9 double weightInKilograms = weight / KILOGRAMS_PER_POUND;
10 double heightInMeters = height / METERS_PRE_INCH;
11 System.out.println((float)weightInKilograms+" "+(float)heightInMeters);
12 }
13 }
总结：本道题同样很简单，需要实现的是国际制单位与英制之间的换算。可以实现最终结果，但问题是复杂度过高，下一次写代码时应注意规避这一点。
计算一个数列中所有奇数的和。
输入格式:
十个整数，以空格分隔。例如：1 2 3 4 5 6 7 8 9 0。
输出格式:
输入数列中所有奇数之和。例如：25。
输入样例:
在这里给出一组输入。例如：
1 2 3 4 5 6 7 8 9 0
输出样例:
在这里给出相应的输出。例如：
25 1 import java.util.Scanner;
2 public class Main{
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 int n = 0;
6 int number=0;
7 //int x;
8 while(n>=0&&n<10)
9 {
10
11 int x = input.nextInt();
12
13 if(x%2!=0)
14 number=number+x;
15 n++;
16 }
17 System.out.println(number);
18
19 }
20 }
总结：这一道题同样不难，需要计算一段数列中奇数的和。但同样面临代码复杂度过高的问题。
房屋交易在日常生活中非常常见的事情，房屋交易时要额外支付各种税费，按2022年房产交易新政策的规定买房人应缴纳税费包括：
1、契税：首次购房评估额90平（含）内1%、90平-144平（含）内1.5%，超过144平或非首 次3%，买方缴纳。
2、印花税：房款的0.05%。
3、交易费：3元/平方米。
4、测绘费：1.36元/平方米。
5、权属登记费及取证费：一般情况是在200元内。
输入格式:
四个数据，以空格分隔：
1、第几次购房（整数）
2、房款（整数/单位万元）
3、评估价（整数/单位万元）
4、房屋面积（浮点数/单位平方米）。
例如：1 100 100 90。
输出格式:
契税、印花税、交易费、测绘费（以元为单位），以空格分隔。例如：10000.0 500.0 270.0 122.4
输入样例:
在这里给出一组输入。例如：
1 100 100 90
输出样例:
在这里给出相应的输出。例如：
10000.0 500.0 270.0 122.4 1 import java.util.Scanner;
2 public class Main{
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 int time = input.nextInt();
6 int housepayment = input.nextInt();
7 int evaluatedprice = input.nextInt();
8 float housearea = input.nextFloat();
9 double deedtax;
10 if(time==1&&0<housearea&&housearea<=90)
11 deedtax = evaluatedprice * 0.01*10000;
12 else if(time==1&&90<housearea&&housearea<=144)
13 deedtax = 10000.0 * evaluatedprice * 0.015;
14 else{
15 deedtax = 10000.0 * evaluatedprice * 0.03;
16 }
17 double yinhuatax;
18 yinhuatax =10000.0 * housepayment * 0.0005;
19 double tradefee;
20 tradefee=3*housearea;
21 double cehuifee;
22 cehuifee = 1.36*housearea;
23 System.out.println((float)deedtax+" "+(float)yinhuatax+" "+(float)tradefee+" "+(float)cehuifee);
24 }
25 }
一款网游中包括4个种族：人类、精灵、兽人、暗精灵，每个种族包含三种角色：战士、法师、射手。玩家新建人物时需要选择种族和角色。请编写角色选择程序。
输入格式:
两个整数：游戏种族、角色的选项，以空格分隔。例如：1 2。
种族选项设定为：1、人类 2、精灵 3、兽人 4、暗精灵
角色选项设定为：1、战士 2、法师 3、射手
输出格式:
所选择的种族、角色的名称，以空格分隔。例如：人类 法师
若输入数值超出选项范围，输出“Wrong Format”
输入样例1:
在这里给出一组输入。例如：
1 2
输出样例1:
在这里给出相应的输出。例如：
人类 法师
输入样例2:
在这里给出一组输入。例如：
1 6
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
1 import java.util.Scanner;
2 public class Main{
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5
6 int number1 = input.nextInt();
7 int number2 = input.nextInt();
8 if(number1<1||number1>4||number2<1||number2>3)
9 System.out.println("Wrong Format");
10 if(number1==1&&number2==1)
11 System.out.println("人类 战士");
12 if(number1==1&&number2==2)
13 System.out.println("人类 法师");
14 if(number1==1&&number2==3)
15 System.out.println("人类 射手");
16 if(number1==2&&number2==1)
17 System.out.println("精灵 战士");
18 if(number1==2&&number2==2)
19 System.out.println("精灵 法师");
20 if(number1==2&&number2==3)
21 System.out.println("精灵 射手");
22 if(number1==3&&number2==1)
23 System.out.println("兽人 战士");
24 if(number1==3&&number2==2)
25 System.out.println("兽人 法师");
26 if(number1==3&&number2==3)
27 System.out.println("兽人 射手");
28 if(number1==4&&number2==1)
29 System.out.println("暗精灵 战士");
30 if(number1==4&&number2==2)
31 System.out.println("暗精灵 法师");
32 if(number1==4&&number2==3)
33 System.out.println("暗精灵 射手");
34 }
35 }
学校的学号由8位数字组成，前两位是入学年份（省略了20）；第3、4位是学院编号，01代表材料学院，02代表机械学院，03代表外语学院，20代表软件学院；
第5、6位是学院内部班级编号，最后两位是班级内部学号。如：18011103，入学年份是2018年，材料学院，11班，03号
输入格式:
8位数字组成的学号。例如：18011103
注意：输入学号不是8位或者学院编号不是01、02、03、20其中之一，属于非法输入
输出格式:
学号每一项的完整说明。例如：
入学年份：2018年
学院：材料学院
班级：11
学号：03
注意：如非法输入，输出“Wrong Format"
输入样例:
在这里给出一组输入。例如：
18011103
输出样例:
在这里给出相应的输出。例如：
入学年份：2018年
学院：材料学院
班级：11
学号：03
输入样例1:
在这里给出一组输入。例如：
18013
输出样例1:
在这里给出相应的输出。例如：
Wrong Format
1
2 import java.util.Scanner;
3 public class Main{
4 public static void main(String[] args){
5 Scanner input = new Scanner(System.in);
6 String s1=input.nextLine();
7
8 if(s1.length()==8&&((s1.charAt(2)=='0'&&s1.charAt(3)=='1')||(s1.charAt(2)=='0'&&s1.charAt(3)=='2')||(s1.charAt(2)=='0'&&s1.charAt(3)=='3')||(s1.charAt(2)=='2'&&s1.charAt(3)=='0')))
9 {
10 System.out.println("入学年份："+"20"+s1.charAt(0)+s1.charAt(1)+"年");
11 if(s1.charAt(2)=='0'&&s1.charAt(3)=='1')
12 System.out.println("学院：材料学院");
13 if(s1.charAt(2)=='0'&&s1.charAt(3)=='2')
14 System.out.println("学院：机械学院");
15 if(s1.charAt(2)=='0'&&s1.charAt(3)=='3')
16 System.out.println("学院：外语学院");
17 if(s1.charAt(2)=='2'&&s1.charAt(3)=='0')
18 System.out.println("学院：软件学院");
19
20 System.out.println("班级："+s1.charAt(4)+s1.charAt(5));
21 System.out.println("学号："+s1.charAt(6)+s1.charAt(7));
22 }
23 else
24 System.out.println("Wrong Format");
25 }
26 }
7.7-8 巴比伦法求平方根近似值
巴比伦法求n的近似值可以用以下公式：
nextGuess = (lastGuess+n/lastGuess)/2
程序初始运行时lastGuess可赋予一个最初的猜测值。当由公式求得的nextGuess和lastGuess相差较大时，把nextGuess的值赋给lastGuess，继续以上过程，直至nextGuess和lastGuess几乎相同，此时lastGuess或者nextGuess就是平方根的近似值。
本题要求：nextGuess和lastGuess的差值小于0.00001时认为两者几乎相同
输入格式:
1、两个浮点数，以空格分隔，第一个是n，第二个是lastGuess最初的猜测值。例如：2 1。
2、若输入的两个数中包含负数或者lastGuess初始输入为0，认定为非法输入
输出格式:
1、输出n的平方根近似值：lastGuess。例如：1.4142157
2、非法输入时输出："Wrong Format"
输入样例:
在这里给出一组输入。例如：
2 1
输出样例:
在这里给出相应的输出。例如：
1.4142157
输入样例1:
在这里给出一组输入1。例如：
2 -1
输出样例:
在这里给出相应的输出。例如：
Wrong Format 1 import java.util.Scanner;
2 public class Main{
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 float n = input.nextFloat();
6 float lastGuess = input.nextFloat();
7 float nextGuess=(lastGuess+n/lastGuess)/2;
8
9 if(n<0||lastGuess<=0)
10 System.out.println("Wrong Format");
11 else
12 {
13 while(Math.abs(lastGuess-nextGuess)>=0.00001)
14 {
15 lastGuess=nextGuess;
16 nextGuess = (lastGuess+n/lastGuess)/2;
17
18 }
19 System.out.println(lastGuess);
20 }
21 }
22 }
8.7-9 二进制数值提取
在一个字符串中提取出其中的二进制数值序列，。
输入格式:
一个由0、1构成的序列，以-1为结束符，非0、1字符视为正常输入，但忽略不计，未包含结束符的序列视为非法输入。例如：abc00aj014421-1
输出格式:
将输入的序列去掉非0、1字符以及结尾符的数据内容，
注：结束符-1之后的0\1字符忽略不计。
例如：00011。
输入样例:
在这里给出一组输入。例如：
abc00aj014421-1
输出样例:
在这里给出相应的输出。例如：
00011
输入样例1:
在这里给出一组输入。例如：
a0571-1k001y
输出样例1:
在这里给出相应的输出。例如：
01
1 import java.util.Scanner;
2 public class Main{
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 String s1=input.nextLine();
6 String s2="";
7 int i=0,flag=1;
8 while(i>=0&&i<s1.length())
9 {
10 if(s1.charAt(i)=='0'||s1.charAt(i)=='1')
11 s2=s2+s1.charAt(i);
12
13 if(s1.charAt(i)=='-'&&s1.charAt(i+1)=='1')
14 {
15 //flag=0;
16 System.out.println(s2);
17 return;
18 //i=s1.length();
19
20 }
21 i++;
22
23 }
24 //if(flag==1)
25 System.out.println("Wrong Format");
26 }
27 }
9.7-7 判断三角形类型
输入三角形三条边，判断该三角形为什么类型的三角形。
输入格式:
在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[1,200]。
输出格式:
（1）如果输入数据非法，则输出“Wrong Format”；
（2）如果输入数据合法，但三条边不能构成三角形，则输出“Not a triangle”；
（3）如果输入数据合法且能够成等边三角形，则输出“Equilateral triangle”；
（3）如果输入数据合法且能够成等腰直角三角形，则输出“Isosceles right-angled triangle”；
（5）如果输入数据合法且能够成等腰三角形，则输出“Isosceles triangle”；
（6）如果输入数据合法且能够成直角三角形，则输出“Right-angled triangle”；
（7）如果输入数据合法且能够成一般三角形，则输出“General triangle”。
输入样例1:
在这里给出一组输入。例如：
50 50 50.0
输出样例1:
在这里给出相应的输出。例如：
Equilateral triangle
输入样例2:
在这里给出一组输入。例如：
60.2 60.2 80.56
输出样例2:
在这里给出相应的输出。例如：
Isosceles triangle
输入样例3:
在这里给出一组输入。例如：
0.5 20.5 80
输出样例3:
在这里给出相应的输出。例如：
Wrong Format 1 import java.util.Scanner;
2 public class Main{
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 double a = input.nextDouble();
6 double b = input.nextDouble();
7 double c = input.nextDouble();
8 if((a>=1&&a<=200)&&(b>=1&&b<=200)&&(c>=1&&c<=200))
9 {
10 if(((a+b<=c)||(Math.abs(a-b)>=c))||((a+c<=b)||(Math.abs(a-c)>=b))||((c+b<=a)||(Math.abs(b-c)>=a)))
11 System.out.println("Not a triangle");
12 else
13 {
14 if(a==b&&b==c)
15 System.out.println("Equilateral triangle");
16 else if((a==b&&(Math.abs(a*a+b*b-c*c)<0.00001))||(a==c&&(Math.abs(a*a+c*c-b*b)<0.00001))||(a==b&&(Math.abs(c*c+b*b-a*a)<0.00001)))
17 System.out.println("Isosceles right-angled triangle");
18 else if((a==b&&a!=c)||(a==c&&a!=b)||(c==b&&a!=c))
19 System.out.println("Isosceles triangle");
20 else if((Math.abs(a*a+b*b-c*c)<0.00001)||(Math.abs(a*a+c*c-b*b)<0.00001)||(Math.abs(c*c+b*b-a*a)<0.00001))
21 System.out.println("Right-angled triangle");
22 else
23 System.out.println("General triangle");
24
25
26 }
27 }
28 else
29 System.out.println("Wrong Format");
30 }
31 }
总结：本题的难度不是很高，根据题目的要求，我们需要做的是由输出三条边的值，判断能否构成三角形，如果能，则还需要判断是构成等边三角形，还是等腰直角三角形，
还是等腰三角形，还是直角三角形，抑或是一般三角形。本题的解题思路是：先判断能否构成三角形，如果不能，输出Not a triangle，如果能，就通过if-else语句判断是不是
等边三角形，等腰直角三角形，等腰三角形，直角三角形，一般三角形。每当满足一种情况就输出相应的答案，并结束判断。解题过程中碰到的踩坑点是要用Math.abs(a*a+
b*b-c*c)<0.00001判断是否为直角三角形。另外需要解决的问题是下次写代码时要注意代码复杂度过高的问题，可以通过多写几个类，以及将一个方法拆成多个方法以降低代
码的复杂度。
（2）7-1 字母-数字转换
输入一个由英文字母组成的字符串（大小写均可），将所有英文字母转换成它们在字母表中的序号，例如：“AbbcD”转换为“12234”。
输入格式:
由英文字母组成的字符串（大小写均可）。例如：“AbbcD”
若包含非英文字母，视为非法输入。
输出格式:
所有英文字母转换成它们在字母表中的序号，例如：“12234”。
非法输入输出"Wrong Format".
输入样例:
在这里给出一组输入。例如：
AbbcD
输出样例:
在这里给出相应的输出。例如：
12234
输入样例1:
在这里给出一组输入。例如：
AFOPI
输出样例1:
在这里给出相应的输出。例如：
1615169
输入样例2:
在这里给出一组输入。例如：
c3u
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
1 import java.util.Scanner;
2 public class Main{
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 String s = input.nextLine();
6 int i=0;
7
8 int flag=0;
9 for(i=0;i<s.length();i++)
10 {
11 if(!((s.charAt(i)>='a'&&s.charAt(i)<='z')||(s.charAt(i)>='A'&&s.charAt(i)<='Z')))
12 flag=1;
13 }
14 if(flag!=0)
15 {
16 System.out.println("Wrong Format");
17 }
18 if(flag==0)
19 {
20 for(i=0;i<s.length();i++)
21 {
22 if(s.charAt(i)>='a'&&s.charAt(i)<='z')
23 System.out.print(s.charAt(i)-'a'+1);
24 if(s.charAt(i)>='A'&&s.charAt(i)<='Z')
25 System.out.print(s.charAt(i)-'A'+1);
26 }
27 }
28
29 }
30 }
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
输入样例:
在这里给出一组输入。例如：
1111011101011111111111
输出样例:
在这里给出相应的输出。例如：
1:11101011
输入样例1:
在这里给出一组输入。例如：
11110111010111111001001101111111011111111101111
输出样例1:
在这里给出相应的输出。例如：
1:11101011
2:01001101
3:validate error
输入样例2:
输入数据不足11位。例如：
111101
输出样例2:
在这里给出相应的输出。例如：
null data
输入样例3:
输入数据全1没有起始位。例如：
1111111111111111
输出样例3:
在这里给出相应的输出。例如：
null data
输入样例4:
输入数据全1没有起始位。例如：
111101110101111111101111111101
输出样例4:
在这里给出相应的输出。例如：
1:11101011
2:parity check error
输入样例5:
两组数据结束符和奇偶校验均不合格。例如：
111000000000000011100000000000000
输出样例5:
在这里给出相应的输出。例如：
1:validate error
2:validate error
输入样例6:
两组数据，数据之间无空闲位。例如：
1110000000001100111000001
输出样例6:
在这里给出相应的输出。例如：
1:00000000 2:01110000
1 import java.util.Scanner;
2 public class Main{
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 String s = input.nextLine();
6 String ch="";
7 int j=0;
8 int i=0;
9 int t=1;
10 int count=0;
11 if(s.length()<11)
12 System.out.println("null data");
13 else
14 {
15 for(i=0;i<s.length();i++)
16 {
17 if(s.charAt(i)=='1')
18 j++;
19 }
20 if(j==s.length())
21 { System.out.println("null data");return ;}
22 else
23 {
24 i=0;
25 while(i<=s.length()-11)
26 {
27 if(s.charAt(i)=='0'){
28 ch=s.substring(i,i+11);
29
30 if(ch.charAt(10)!='1')
31 {
32 System.out.println(t+":"+"validate error");
33 t++;
34 i=i+11;
35 }
36 else
37 {
38 for( j=1;j<9;j++)
39 {
40 if(ch.charAt(j)=='1')
41 count++;
42
43 }
44 if(count%2==0)
45 {
46 if(ch.charAt(9)!='1')
47 {
48 System.out.println(t+":"+"parity check error");
49 t++;
50 i=i+11;
51 }
52 else
53 {
54 System.out.println(t+":"+ch.substring(1,9));
55 t++;
56 i=i+11;
57 }
58 }
59 else
60 {
61 if(ch.charAt(9)!='0')
62 {
63 System.out.println(t+":"+"parity check error");
64 t++;
65 i=i+11;
66 }
67 else
68 {
69 System.out.println(t+":"+ch.substring(1,9));
70 t++;
71 i=i+11;
72 }
73 }
74 }
75
76 }
77 else
78 i++;
79 }
80 }
81
82
83 }
84 }
85 }
踩坑心得：最开始的时候在条件判断语句里，我都采用的是让sub.string( )截出来的字符串直接用“==”与一个字符串相比，导致一直在报错。刚开始我一直以为是sub.string( )导致的错，
在翻了很多遍书以及CSDN了很多次以后仍然没有找到错误，就放弃了使用sub.string( )，转而使用charAt( )去代替，虽然要写的东西多了很多，但终于没有再报错了！后来，下午上课，
听老师讲到相关东西才明白两个字符串不能直接用“==”去比较。还有就是一开始以为所有的奇校验都为1，这也导致我在校验码的测试点中错了很多。还有一个低级错误就是最开始我都
是用println( )输出，这导致输出的结果是序号与数据不在同一行。当然，这道题还有一个普遍的问题就是圈复杂度太高。对于这道题，我把所有给出的样例都过了，但仍然有几个测试点
过不了，后来自己尝试着写了几个例子，仍然没有发现错误所在。
改进建议：下一次我们在做题的时候，应该更细心的检查错误之处，不要想当然的以为一定是某个点错了而忽略另外一个点，因为真正的错误可能是一个非常细微的点，这会帮我们节省
太多时间。还有就是读题目的时候当碰到某个不明白的知识点，应该去查资料弄明白，因为能否读懂题目关乎到我们能否将题目做出来。我们在做题的时候，经常会出现答案错误的情况，
我觉得碰到这种情况可以先在测试区测试几个样例看看错误的输出是什么样的，从而更好改动代码。还有就是平时应该多积累一些相关知识，避免犯一些低级错误。
总结：通过这道题我学会了很多。比如说：字符串不能直接用“==”去比较，奇校验码在有奇数个1时，校验位为0，偶数个1时，校验位为1。println( )输出会换行，但print( )不会。对于如何
降低复杂度，可以通过把一个类拆分成多个类，把一个方法拆分成多个方法。本道题的不足之处是并没有把所有的测试点都过了，而且到最后也没有找出没有过的原因。
学校学生学号格式定义如下：
2位年级号+2位学院号+2位班级号+2位序号，如19041103，
编写程序处理用全院学生学号连接起来的长字符串，学院编号为20，包括17、18、19、20四个年级，请从字符串中提取特定两个班级202017班、202061班同学的学号后四位输出，输出编号之间用空格分隔，不换行。
注意：需要排除非法输入。
输入格式:
全院学生学号组成的长字符串（学号之间无分隔）
学号格式定义如下：
2位年级号+2位学院号+2位班级号+2位序号，如19041103，
输出格式:
特定两个班级202017班、202061班同学的学号后四位
如：1701 6103 1704
输入样例1:
在这里给出一组输入。例如：
2020610120201702202051132020110320201706
输出样例1:
在这里给出相应的输出。例如：
6101 1702 1706
输入样例2（第一个学号多输入一位）:
在这里给出一组输入。例如：
20206100120201702202051132020110320201706
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
输入样例3（第一个学号少输入一位数字）:
在这里给出一组输入。例如：
202061120201702202051132020110320201706
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
输入样例3（学号之间有空格）:
在这里给出一组输入。例如：
2020610120201702 202051132020110320201706
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
1 import java.util.Scanner;
2 public class Main{
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 String s = input.nextLine();
6 int i=0;
7 int flag=0;
8 int j;
9 if(s.length()<8)
10 {
11 System.out.println("Wrong Format");
12 }
13 else
14 {
15 if(s.length()%8!=0)
16 {
17 System.out.println("Wrong Format");
18
19 }
20 else
21 {
22 for(i=0;i<s.length();i=i+8)
23 {
24
25
26 if((s.charAt(i)=='2'&&s.charAt(i+1)=='0'&&s.charAt(i+2)=='2'&&s.charAt(i+3)=='0'&&s.charAt(i+4)=='1'&&s.charAt(i+5)=='7')||(s.charAt(i)=='2'&&s.charAt(i+1)=='0'&&s.charAt(i+2)=='2'&&s.charAt(i+3)=='0'&&s.charAt(i+4)=='6'&&s.charAt(i+5)=='1'))
27 {
28 for(j=i+4;j<i+8;j++)
29 {
30 //System.out.print((String)s.charAt(i+4)+(String)s.charAt(i+5)+(String)s.charAt(i+6)+(String)s.charAt(i+7) );
31 System.out.print(s.charAt(j));
32 flag++;
33 }
34 if(flag%4==0&&i+8!=s.length())
35 System.out.print(" ");
36
37
38 }
39 }
40 }
41 }
42
43
44 }
45 }
（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
输入样例:
整数输入。例如：
0,0 1,1
输出样例:
在这里给出相应的输出。例如：
1.4142135623730951
输入样例1:
带符号double类型实数输入。例如：
+2,-2.3 0.9,-3.2
输出样例1:
在这里给出相应的输出。例如：
1.42126704035519
输入样例2:
格式非法。例如：
++2,-2.3 0.9,-3.2
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
输入样例3:
点的数量超过两个。例如：
+2,-2.3 0.9,-3.2 +2,-2.3
输出样例3:
在这里给出相应的输出。例如：
wrong number of points 1 import java.util.Scanner;
2 import java.util.regex.Matcher;
3 import java.util.regex.Pattern;
4 public class Main{
5 public static void main(String[] args){
6 Scanner input = new Scanner(System.in);
7 String s1=input.nextLine();
8 int i=0;
9 int j=0;
10 int flag=0;
11 Double[]b=new Double[4];
12 for(i=0;(i+2)<s1.length();i++)
13 {
14
15 if((s1.charAt(i)=='+'&&s1.charAt(i+1)==',')||(s1.charAt(i)=='-'&&s1.charAt(i+1)==','))
16 {
17 //System.out.println("Wrong Format");
18 flag=1;
19 break;
20 }
21 if(s1.charAt(i)=='0'&&(s1.charAt(i+1)>='0'&&s1.charAt(i+1)<='9'))
22 {
23 // System.out.println("Wrong Format");
24 flag=1;
25 break;
26 }
27 if((s1.charAt(0)=='.'&&s1.charAt(1)=='1')||(s1.charAt(0)=='.'&&s1.charAt(1)=='2')||(s1.charAt(0)=='.'&&s1.charAt(1)=='3')||
28 (s1.charAt(0)=='.'&&s1.charAt(1)=='4')||(s1.charAt(0)=='.'&&s1.charAt(1)=='5')||(s1.charAt(0)=='.'&&s1.charAt(1)=='6')||(s1.charAt(0)=='.'&&s1.charAt(1)=='7')||(s1.charAt(0)=='.'&&s1.charAt(1)=='8')||(s1.charAt(0)=='.'&&s1.charAt(1)=='9'))
29 {
30 // System.out.println("Wrong Format");
31 flag=1;
32 break;
33 }
34 if(s1.charAt(i)=='.'&&s1.charAt(i+1)==',')
35 {
36 // System.out.println("Wrong Format");
37 flag=1;
38 break;
39 }
40
41 if(s1.charAt(i)=='+'&&s1.charAt(i+1)=='+'&&s1.charAt(i+2)=='+')
42 {
43 // System.out.println("Wrong Format");
44 flag=1;
45 break;
46 }
47
48 if(s1.charAt(i)=='0'&&s1.charAt(i+1)=='0'&&s1.charAt(i+2)=='0')
49 {
50 // System.out.println("Wrong Format");
51 flag=1;
52 break;
53 }
54 if(s1.charAt(i)=='0'&&s1.charAt(i+1)=='.'&&s1.charAt(i+2)=='0')
55 {
56 // System.out.println("Wrong Format");
57 flag=1;
58 break;
59 }
60 if(s1.charAt(i)=='+'&&s1.charAt(i+1)=='0')
61 {
62 // System.out.println("Wrong Format");
63 flag=1;
64 break;
65 }
66 }
67 if(flag==1)
68 System.out.println("Wrong Format");
69 /*for(i=0;(i+1)<s1.length();i++)
70 {
71 if(s1.charAt(i)=='+'&&s1.charAt(i+1)=='+'||s1.charAt(i)=='0'&&s1.charAt(i+1)=='0'||s1.charAt(i)==','&&s1.charAt(i+1)==' '||s1.charAt(i)==','&&s1.charAt(i+1)=='-')
72 System.out.println("Wrong Format");
73 return;
74 }*/
75
76 String s2="";
77 s2=s1.replace(","," ");
78 String[]a=s2.split(" ");
79 if(a.length>4)
80
81 System.out.println("wrong number of points");
82 else if(s1.matches("[+-]?([0-9]+(\\.[0-9]+)?),[+-]?([0-9]+(\\.[0-9]+)?) [+-]?([0-9]+(\\.[0-9]+)?),[+-]?([0-9]+(\\.[0-9]+)?)")==false)
83 System.out.println("Wrong Format");
84
85
86 else
87 {
88 for(j=0;j<4;j++)
89 b[j]=Double.parseDouble(a[j]);
90 // s=Math.sqrt((b[3]-b[1])*(b[3]-b[1])-(b[2]-b[0])*(b[2]-b[0]));
91 System.out.println(Math.sqrt((b[3]-b[1])*(b[3]-b[1])+(b[2]-b[0])*(b[2]-b[0])));
92 }
93
94
95 }
96 }
踩坑心得：做这道题，我的思路是排除所有错误输入后，利用两点之间的距离计算公式把结果算出来，我所知道的情况有：合法输入：（1）1，1 1，2 （2）+1，1 1，2
（3）1，1 1，01 非法输入：（1）++1，1 1，2 （2）+1+，1 1，2 （3）+01，1 1，2 （4）.1，1 1，2 （5）1.，1 1，2 （6）.,1 1，2 （7）+
++，1 1，2 （8）000，1 1，1，但把所有情况写上后，得分也只有8分，后来又尝试用正则表达式，得分也只有9分，还有的一分当时找了很久也没有找到。做完这一步后，需
要把输入的字符串形式转化为坐标去计算，我采用的是用一个double型的b[ ]去存它。这道题的复杂度也很高，这也是一个普遍的问题。
改进建议：因为这道题的非法输入形式千变万化，所以很难把所有的错误情况都排除掉，这也正是本题的最大难点所在。我觉得可以采用正则表达式把正确的输入写入，从而可以减
少很多麻烦，节省时间。对于复杂度太高的问题，我觉得可以通过把一个类拆分成多个类，把一个方法拆分成多个方法，减少if-else的使用。
总结：通过这道题，我学会了在输入情况很复杂的时候，采用正则表达式可以节省大量时间，简化题目。通过看书，了解了正则表达式一些基本的使用方法。我希望在以后做题的时
候，可以先想出一个相对较简便的方法再去做，而不是一拿到题目就去做。
用户输入一组选项和数据，进行与直线有关的计算。选项包括：
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:
选项1，两点重合。例如：
1:-2,+5 -2,+5
输出样例:
在这里给出相应的输出。例如：
points coincide
输入样例2:
选项1，斜率无穷大的线。例如：
1:-2,3 -2,+5
输出样例:
在这里给出相应的输出。例如：
Slope does not exist
输入样例3:
选项1，斜率无穷大。例如：
1:-2,3 -2,+5
输出样例:
在这里给出相应的输出。例如：
Slope does not exist
输入样例4:
选项1，符合格式输入，带符号/不带符号数混合。例如：
1:-2.5,3 -2,+5.3
输出样例:
在这里给出相应的输出。例如：
4.6
输入样例5:
选项2，计算第一个点到另外两点连线的垂直距离。例如：
2:0,1 1,0 2,0
输出样例:
在这里给出相应的输出。例如：
1.0
输入样例6:
选项3，判断三个点是否在一条线上。例如：
3:0,1 2,2 5,3
输出样例:
在这里给出相应的输出。例如：
false
输入样例7:
选项4，判断两条线是否平行。例如：
4:0,1 0,2 2,1 3,0
输出样例:
在这里给出相应的输出。例如：
false
输入样例8:
选项5，判断两条线的交点。例如：
5:0,0 -1,-1 0,2 3,-1
输出样例:
在这里给出相应的输出，交点坐标之间以英文","分隔，判断结果与坐标之间以一个英文空格分隔。例如：
1.0,1.0 true
输入样例9:
选项5，判断两条线的交点。但两条线平行例如：
5:0,0 -1,-1 2,3 3,4
输出样例:
在这里给出相应的输出，交点坐标之间以英文","分隔，判断结果与坐标之间以一个英文空格分隔。例如：
is parallel lines,have no intersection point
1 import java.util.Scanner;
2 public class Main {
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 String s1=input.nextLine();
6 double b[]=new double[8];
7 double k=0;
8 int i=0;
9 int flag=0;
10 /* for(i=2;(i+2)<s1.length();i++)
11 {
12 if((s1.charAt(i)=='+'&&s1.charAt(i+1)=='+')||(s1.charAt(i)=='-'&&s1.charAt(i+1)=='-'))
13 {
14 // System.out.println("Wrong Format");
15 flag=1;
16 break;
17 }
18 if((s1.charAt(i)=='+'&&s1.charAt(i+1)==',')||(s1.charAt(i)=='-'&&s1.charAt(i+1)==','))
19 {
20 //System.out.println("Wrong Format");
21 flag=1;
22 break;
23 }
24 if(s1.charAt(i)=='0'&&(s1.charAt(i+1)>='0'&&s1.charAt(i+1)<='9'))
25 {
26 // System.out.println("Wrong Format");
27 flag=1;
28 break;
29 }
30 if((s1.charAt(0)=='.'&&s1.charAt(1)=='1')||(s1.charAt(0)=='.'&&s1.charAt(1)=='2')||(s1.charAt(0)=='.'&&s1.charAt(1)=='3')||
31 (s1.charAt(0)=='.'&&s1.charAt(1)=='4')||(s1.charAt(0)=='.'&&s1.charAt(1)=='5')||(s1.charAt(0)=='.'&&s1.charAt(1)=='6')||(s1.charAt(0)=='.'&&s1.charAt(1)=='7')||(s1.charAt(0)=='.'&&s1.charAt(1)=='8')||(s1.charAt(0)=='.'&&s1.charAt(1)=='9'))
32 {
33 // System.out.println("Wrong Format");
34 flag=1;
35 break;
36 }
37 if(s1.charAt(i)=='.'&&s1.charAt(i+1)==',')
38 {
39 // System.out.println("Wrong Format");
40 flag=1;
41 break;
42 }
43
44 if(s1.charAt(i)=='+'&&s1.charAt(i+1)=='+'&&s1.charAt(i+2)=='+')
45 {
46 // System.out.println("Wrong Format");
47 flag=1;
48 break;
49 }
50
51 if(s1.charAt(i)=='0'&&s1.charAt(i+1)=='0'&&s1.charAt(i+2)=='0')
52 {
53 // System.out.println("Wrong Format");
54 flag=1;
55 break;
56 }
57 if(flag==1)
58 System.out.println("Wrong Format"); */
59
60 //int t=0;
61
62
63 if(s1.charAt(1)!=':'||s1.charAt(0)>'5'||s1.charAt(0)<'1')
64 {
65 System.out.print("Wrong Format");
66 return;
67 }
68
69 String s2=s1.substring(2);
70 String s3=s2.replace(","," ");
71 String[]s4=s3.split(" ");
72 int count=0;
73 for(i=0;i<s2.length()-1;i++)
74
75 {
76 if(s2.charAt(i)==' ')
77 count++;
78 }
79 if(count==0)
80 {
81 System.out.print("Wrong Format");
82 return;
83 }
84 for(int j=0;j<s2.length()-1;j++)
85 {
86 if((s2.charAt(j)=='+'&&s2.charAt(j+1)=='+')||(s2.charAt(j)=='-'&&s2.charAt(j+1)=='-')||(s2.charAt(j)=='+'&&s2.charAt(j+1)=='-')||(s2.charAt(j)=='-'&&s2.charAt(j+1)=='+')||(s2.charAt(j)=='.'&&s2.charAt(j+1)==',')||(s2.charAt(j)==','&&s2.charAt(j+1)=='.')||(s2.charAt(j)=='0'&&s2.charAt(j+1)=='0')||(s2.charAt(j)=='.'&&s2.charAt(j+1)==' ')||(s2.charAt(j)==' '&&s2.charAt(j+1)=='.')||(s2.charAt(j)=='.'&&s2.charAt(j+1)=='.')||(s2.charAt(j)==' '&&s2.charAt(j+1)==',')||(s2.charAt(j)==','&&s2.charAt(j+1)==' ')||(s2.charAt(j)==' '&&s2.charAt(j+1)==' ')||(s2.charAt(j)==','&&s2.charAt(j+1)==',')||s2.charAt(0)=='.'||s2.charAt(0)==',')
87 {
88 System.out.print("Wrong Format");
89 return;
90 }
91 }
92 if(s1.charAt(0)=='1')
93 {
94 /*String s2=s1.substring(2);
95 String s3=s2.replace(","," ");
96 String[]s4=s3.split(" ");*/
97 if(s4.length!=4)
98 {
99 System.out.print("wrong number of points");
100 return;
101 }
102 else
103 {
104 //if(s2.matches("[+-]?([0-9]+(\\.[0-9]+)?),[+-]?([0-9]+(\\.[0-9]+)?) [+-]?([0-9]+(\\.[0-9]+)?),[+-]?([0-9]+(\\.[0-9]+)?)")==false)
105 // System.out.println("Wrong Format");
106 //else
107 //{
108 for(int j=0;j<4;j++)
109
110 b[j]=Double.parseDouble(s4[j]);
111
112 if(b[0]==b[2]&&b[1]==b[3])
113 {
114 System.out.print("points coincide");
115 return;
116 }
117 else
118 {
119 if(b[0]==b[2])
120 {
121 System.out.print("Slope does not exist");
122 return;
123 }
124 else
125 {
126 k=(b[3]-b[1])/(b[2]-b[0]);
127 System.out.print(k);
128 return;
129 }
130 }
131 // }
132 }
133 }
134 if(s1.charAt(0)=='2'||s1.charAt(0)=='3')
135 {
136 /*String s2=s1.substring(2);
137 String s3=s2.replace(","," ");
138 String[]s4=s3.split(" ");*/
139 if(s4.length!=6)
140 {
141 System.out.print("wrong number of points");
142 return;
143 }
144 else
145 {
146 for(int j=0;j<6;j++)
147
148 b[j]=Double.parseDouble(s4[j]);
149
150 // if(s2.matches("[+-]?([0-9]+(\\.[0-9]+)?),[+-]?([0-9]+(\\.[0-9]+)?) [+-]?([0-9]+(\\.[0-9]+)?),[+-]?([0-9]+(\\.[0-9]+)?) [+-]?([0-9]+(\\\\.[0-9]+)?),[+-]?([0-9]+(\\\\.[0-9]+)?)")==false)
151 // {
152 // System.out.print("Wrong Format");
153 //return;
154 // }
155 // else
156 // {
157 if(s1.charAt(0)=='2')
158 {
159 if(b[2]==b[4]&&b[3]==b[5])
160 {
161 System.out.print("points coincide");
162 return;
163 }
164 else
165 {
166 double L=Math.abs((b[3]-b[5])*b[0]+(b[2]-b[4])*b[1]-b[2]*b[5]+b[3]*b[4])/Math.sqrt((b[3]-b[5])*(b[3]-b[5])+(b[2]-b[4])*(b[2]-b[4]));
167 System.out.print(L);
168 return;
169 }
170 }
171 else if(s1.charAt(0)=='3')
172 {
173
174 if((b[0]==b[2]&&b[1]==b[3])||(b[0]==b[4]&&b[1]==b[5])||(b[2]==b[4]&&b[3]==b[5]))
175 {
176 System.out.println("points coincide");
177 return;
178 }
179 else
180 {
181 if(b[2]==b[0]&&b[4]==b[2])
182 {
183 System.out.print("true");
184 return;
185 }
186 else
187 {
188 if((b[2]!=b[0]&&b[4]!=b[2])&&((b[2]-b[0])*(b[5]-b[3])==(b[4]-b[2])*(b[3]-b[1])))
189 {
190 System.out.print("true");
191 return;
192 }
193 else if((b[2]!=b[0]&&b[4]==b[2])||(b[2]==b[0]&&b[4]!=b[2]))
194 {
195 System.out.print("false");
196 return;
197 }
198 else if((b[2]!=b[0]&&b[4]!=b[2])&&((b[2]-b[0])*(b[5]-b[3])!=(b[4]-b[2])*(b[3]-b[1])))
199 {
200 System.out.print("false");
201 return;
202 }
203 }
204 }
205 }
206
207
208 // }
209 }
210 }
211 if(s1.charAt(0)=='4'||s1.charAt(0)=='5')
212 {
213 /*String s2=s1.substring(2);
214 String s3=s2.replace(","," ");
215 String[]s4=s3.split(" ");*/
216 if(s4.length!=8)
217 {
218 System.out.print("wrong number of points");
219 return;
220 }
221 else
222 {
223
224 for(int j=0;j<8;j++)
225
226 b[j]=Double.parseDouble(s4[j]);
227
228 // if(s2.matches("[+-]?([0-9]+(\\.[0-9]+)?),[+-]?([0-9]+(\\.[0-9]+)?) [+-]?([0-9]+(\\.[0-9]+)?),[+-]?([0-9]+(\\.[0-9]+)?) [+-]?([0-9]+(\\\\.[0-9]+)?),[+-]?([0-9]+(\\\\.[0-9]+)?) [+-]?([0-9]+(\\\\.[0-9]+)?),[+-]?([0-9]+(\\\\.[0-9]+)?)")==false)
229 // {
230 // System.out.print("Wrong Format");
231 // return;
232 // }
233 // else
234 // {
235 for(int j=0;j<8;j++)
236
237 b[j]=Double.parseDouble(s4[j]);
238
239 if((b[0]==b[2]&&b[1]==b[3])||(b[7]==b[5]&&b[6]==b[4]))
240 {
241 System.out.print("points coincide");
242 return;
243 }
244 else if(s1.charAt(0)=='4')
245 {
246 if(b[2]==b[0]&&b[6]==b[4])
247 {
248 System.out.print("true");
249 return;
250 }
251 else
252 {
253 if((b[2]!=b[0]&&b[6]!=b[4]))
254 {
255 if((b[3]-b[1])/(b[2]-b[0])==(b[7]-b[5])/(b[6]-b[4]))
256 {
257 System.out.print("true");
258 return;
259 }
260 else
261 {
262 System.out.print("false");
263 return;
264 }
265 }
266 else
267 {
268 System.out.println("false");
269 return;
270 }
271 }
272 }
273 else if(s1.charAt(0)=='5')
274 {
275 if(b[2]==b[0]&&b[6]==b[4])
276 {
277 System.out.print("is parallel lines,have no intersection point");
278 return;
279 }
280 else if((b[3]-b[1])/(b[2]-b[0])==(b[7]-b[5])/(b[6]-b[4]))
281 {
282 System.out.print("is parallel lines,have no intersection point");
283 return;
284 }
285 else
286 {
287 double x=(b[5]*b[6]*b[2]-b[7]*b[4]*b[2]-b[5]*b[6]*b[0]+b[7]*b[4]*b[0]-b[1]*b[2]*b[6]+b[3]*b[0]*b[6]+b[1]*b[2]*b[4]-b[3]*b[4]*b[0])/(b[6]*b[3]-b[6]*b[1]-b[4]*b[3]+b[4]*b[1]-b[2]*b[7]+b[2]*b[5]+b[0]*b[7]-b[0]*b[4]);
288 double y=(-b[5]*b[6]*b[3]+b[7]*b[4]*b[3]+b[5]*b[6]*b[1]-b[7]*b[4]*b[1]+b[1]*b[2]*b[7]-b[1]*b[2]*b[5]-b[3]*b[0]*b[7]+b[3]*b[5]*b[0])/(b[7]*b[2]-b[7]*b[0]-b[5]*b[2]+b[0]*b[5]-b[3]*b[6]+b[3]*b[4]+b[1]*b[6]-b[1]*b[4]);
289 System.out.print(x);
290 System.out.print(",");
291 System.out.print(y);
292
293 if((x>b[0]&&x<b[2]||x>b[4]&&x<b[6]||y>b[1]&&y<b[3]||y>b[5]&&y<b[7])&&(x!=b[0]&&y!=b[1])&&(x!=b[2]&&y!=b[3])&&(x!=b[4]&&y!=b[5])&&(x!=b[6]&&y!=b[7]))
294 {
295
296 System.out.print(" true");
297 return;
298 }
299 else
300 {
301 System.out.print(" false");
302 return;
303 }
304
305 }
306 }
307 }
308 }
309 }
310 //}
311 }
312 //}
踩坑心得：这道题的难度比前一题更高，首先是对于"Wrong Format"的判断比第一题情况更复杂，这也是我这道题的主要失分点，我把前一道题对错误输入判断的代码直接复制过来后，
也很多点没有过，再加上一些东西后，仍然有点没有过。后来我尝试了很多种情况，仍然没有办法把点都过了。然后判断点数与是否重合就比较简单。再然后通过数组接收输入的字符
串，把String转化为double，然后计算斜率，判断平行等等都可以直接去网上找公式。但是令我很疑惑的点是计算交点有一个测试点过不了，一直到现在也没有解决。还有就是这道题的
复杂度依然很高，我觉得如果用类写复杂度应该会降低很多。
改进建议：下次写这种类型的题目时，应该要用类写，这样不仅可以大大降低复杂度，还可以减少很多代码的重复书写，减少做这道题的工作量。在做下道题时可以直接引用相关类，减少
下道题的工作量。还有就是正则表达式对于格式的判断十分重要，今后碰到这种题目时，可以第一考虑正则表达式。
总结：通过这道题，我学到了关于正则表达式的一些更复杂的表达。还有就是意识道自己对类的掌握十分薄弱，今后可以通过尝试多用多写已强化对它的理解。也正是因为这道题，我意识
到类是多么重要，它可以使代码变得简约易读，对于一些需要重复利用的代码可以直接调用，不要重复书写，这也减少了代码出错的概率。
用户输入一组选项和数据，进行与三角形有关的计算。选项包括：
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"，
输入样例1:
选项4，定义线的两点重合。例如：
4:1,0 1,0 0,0 2,0 4,0
输出样例:
在这里给出相应的输出。例如：
points coincide
输入样例2:
选项4，构成三角形的三个点在一条线上，无法构成三角形。例如：
4:1,0 0,2 0,0 0,0 4,0
输出样例:
在这里给出相应的输出。例如：
data error
输入样例3:
选项1，判断等腰、等边三角形。例如：
1:-2,0 2,0 0,4
输出样例:
两个判断结果。例如：
true false
输入样例4:
选项2，输出边长、面积、重心坐标。例如：
2:0,0 3,0 0,1
输出样例:
在这里给出相应的输出。例如：
7.162278 1.5 1.0,0.333333
输入样例5:
选项3，钝角、直角、锐角的判断。例如：
3:0,1 1,0 2,0
输出样例:
在这里给出相应的输出。例如：
true false false
输入样例6:
选项4，直线与三角形交点的数量等于2，输出数量值以及三角形被分割的两部分面积。例如：
4:1,0 0,2 0,0 0,2 4,0
输出样例:
在这里给出相应的输出。例如：
2 1.0 3.0
输入样例7:
选项4，直线与三角形交点的数量少于两个，只输出数量值。例如：
4:-1,0 1,2 0,1 0,-1 2,0
输出样例:
在这里给出相应的输出。例如：
1
输入样例8:
选项5，用射线法判断点是否在三角形内部。例如：
5:0.5,0.5 0,0 0,2 4,0
输出样例:
在这里给出相应的输出，交点坐标之间以英文","分隔，判断结果与坐标之间以一个英文空格分隔。例如：
in the triangle
输入样例9:
选项5，用射线法判断点是否在三角形内部。例如：
5:0,0 -1,-1 2,3 3,4
输出样例:
在这里给出相应的输出。例如：
outof the triangle
1 import java.util.Scanner;
2 public class Main {
3 public static void main(String[] args){
4 Scanner input = new Scanner(System.in);
5 String s1=input.nextLine();
6 if(s1.charAt(1)!=':')
7 System.out.println("Wrong Format");
8 else
9 {
10 if(!(s1.charAt(0)=='1'||s1.charAt(0)=='2'||s1.charAt(0)=='3'||s1.charAt(0)=='4'||s1.charAt(0)=='5'))
11 System.out.println("Wrong Format");
12 else
13 {
14 int i=0;
15 int j=0;
16 int flag=0;
17
18 for(i=0;(i+2)<s1.length();i++)
19 {
20 if((s1.charAt(i)=='+'&&s1.charAt(i+1)=='+')||(s1.charAt(i)=='-'&&s1.charAt(i+1)=='-'))
21 {
22
23 flag=1;
24 break;
25 }
26 if((s1.charAt(i)=='+'&&s1.charAt(i+1)==',')||(s1.charAt(i)=='-'&&s1.charAt(i+1)==','))
27 {
28
29 flag=1;
30 break;
31 }
32 if(s1.charAt(i)=='0'&&(s1.charAt(i+1)>='0'&&s1.charAt(i+1)<='9'))
33 {
34
35 flag=1;
36 break;
37 }
38 if((s1.charAt(0)=='.'&&s1.charAt(1)=='1')||(s1.charAt(0)=='.'&&s1.charAt(1)=='2')||(s1.charAt(0)=='.'&&s1.charAt(1)=='3')||
39 (s1.charAt(0)=='.'&&s1.charAt(1)=='4')||(s1.charAt(0)=='.'&&s1.charAt(1)=='5')||(s1.charAt(0)=='.'&&s1.charAt(1)=='6')||(s1.charAt(0)=='.'&&s1.charAt(1)=='7')||(s1.charAt(0)=='.'&&s1.charAt(1)=='8')||(s1.charAt(0)=='.'&&s1.charAt(1)=='9'))
40 {
41
42 flag=1;
43 break;
44 }
45 if(s1.charAt(i)=='.'&&s1.charAt(i+1)==',')
46 {
47
48 flag=1;
49 break;
50 }
51 if(s1.charAt(i)=='+'&&s1.charAt(i+1)=='+'&&s1.charAt(i+2)=='+')
52 {
53
54 flag=1;
55 break;
56 }
57 if(s1.charAt(i)=='0'&&s1.charAt(i+1)=='0'&&s1.charAt(i+2)=='0')
58 {
59
60 flag=1;
61 break;
62 }
63 if(s1.charAt(i)=='0'&&s1.charAt(i+1)=='.'&&s1.charAt(i+2)=='0')
64 {
65
66 flag=1;
67 break;
68 }
69
70 }
71 if(flag==1)
72 System.out.println("Wrong Format");
73 else
74
75 {
76 double b[]=new double[10];
77 double k=0;
78 double k1=0;
79 double k2=0;
80
81 if(s1.charAt(0)=='1'||s1.charAt(0)=='2'||s1.charAt(0)=='3')
82 {
83 String s2=s1.substring(2);
84 String s3=s2.replace(","," ");
85 String[]s4=s3.split(" ");
86 if(s4.length!=6)
87 System.out.println("wrong number of points");
88 else
89 {
90 for(i=0;i<6;i++)
91 {
92 if(s4[i].matches("[+-]?([0-9]+(\\.[0-9]+)?)")==false)
93 System.out.println("Wrong Format");
94 }
95 for(j=0;j<6;j++)
96
97 b[j]=Double.parseDouble(s4[j]);
98 k1=(b[1]-b[3])/(b[0]-b[2]);
99 k2=(b[5]-b[3])/(b[4]-b[2]);
100 double a=Math.sqrt((b[3]-b[1])*(b[3]-b[1])+(b[2]-b[0])*(b[2]-b[0]));
101 double d=Math.sqrt((b[5]-b[1])*(b[5]-b[1])+(b[4]-b[0])*(b[4]-b[0]));
102 double c=Math.sqrt((b[5]-b[3])*(b[5]-b[3])+(b[4]-b[2])*(b[4]-b[2]));
103 //if(!((a+d>c&&Math.abs(a-d)<c)||(a+c>d&&Math.abs(a-c)<d)||(c+d>a&&Math.abs(c-d)<a)))
104
105 //else
106 //{
107 if(s1.charAt(0)=='1')
108 {
109 if(k1==k2||(b[3]-b[1])*(b[0]-b[4])-(b[1]-b[5])*(b[2]-b[0])==0||(b[0]-b[2]==0&&b[1]-b[3]==0)||(b[0]-b[4]==0&&b[1]-b[5]==0)||(b[2]-b[4]==0&&b[3]-b[5]==0)||(!((a+d>c&&Math.abs(a-d)<c)||(a+c>d&&Math.abs(a-c)<d)||(c+d>a&&Math.abs(c-d)<a))))
110 {
111 System.out.print("data error");
112 return;
113 }
114
115 else
116 {
117 String S1="";
118 String S2="";
119 if(a==d&&d==c)
120 {
121 S1="true";
122 // S2="true";
123 }
124 //else
125 //{
126 else if(a==d||a==c||d==c)
127 {
128 S2="true";
129 //S1="false";
130 }
131 if(!(S1.equals("true")))
132 S1="false";
133 if(!(S2.equals("true")))
134 S2="false";
135 System.out.println(S2+" "+S1);
136 // }
137 }
138 /* if(Math.abs(a-d)<=0.000001&&Math.abs(c-d)<=0.000001)
139 System.out.print("true true");
140 else
141 {
142 if(Math.abs(a-d)<=0.000001||Math.abs(a-c)<=0.000001||Math.abs(c-d)<=0.000001)
143 System.out.print("true false");
144 else
145 System.out.print("false false");
146
147 }*/
148 }
149 if(s1.charAt(0)=='2')
150
151 {
152
153 double a1=Math.sqrt((b[3]-b[1])*(b[3]-b[1])+(b[2]-b[0])*(b[2]-b[0]));
154 double d1=Math.sqrt((b[5]-b[1])*(b[5]-b[1])+(b[4]-b[0])*(b[4]-b[0]));
155 double c1=Math.sqrt((b[5]-b[3])*(b[5]-b[3])+(b[4]-b[2])*(b[4]-b[2]));
156 double C=a1+d1+c1;
157 if(k1==k2||(b[3]-b[1])*(b[0]-b[4])-(b[1]-b[5])*(b[2]-b[0])==0||(b[0]-b[2]==0&&b[1]-b[3]==0)||(b[0]-b[4]==0&&b[1]-b[5]==0)||(b[2]-b[4]==0&&b[3]-b[5]==0)||(!((a+d>c&&Math.abs(a-d)<c)||(a+c>d&&Math.abs(a-c)<d)||(c+d>a&&Math.abs(c-d)<a))))
158 {
159 System.out.print("data error");
160 return;
161 }
162 else
163 {
164 if((C*1e6)%10!=0)
165 System.out.print(String.format("%.6f",C)+" ");
166 else
167 System.out.print(C+" ");
168 double q=Math.abs((b[3]-b[5])*b[0]+(b[4]-b[2])*b[1]+b[2]*b[5]-b[3]*b[4]);
169 double S=q/2;
170 if((S*1e6)%10!=0)
171 System.out.printf("%.6f",S);
172 else
173 System.out.print(S+" ");
174 double X=(b[0]+b[2]+b[4])/3.0;
175 double Y=(b[1]+b[3]+b[5])/3.0;
176 if((X*1e6)%10!=0)
177 System.out.print(String.format("%.6f",X)+",");
178 else
179 System.out.print(X+",");
180 if((Y*1e6)%10!=0)
181 System.out.print(String.format("%.6f",Y));
182 else
183 System.out.print(Y);
184 }
185 }
186 if(s1.charAt(0)=='3')
187 {
188 /* double x1,x2,x3;
189 String S="";
190 x1=(b[2]-b[0])*(b[4]-b[0])*(b[3]-b[1])*(b[5]-b[1]);
191 x2=(b[4]-b[2])*(b[0]-b[2])*(b[5]-b[3])*(b[1]-b[3]);
192 x3=(b[0]-b[4])*(b[2]-b[4])*(b[1]-b[5])*(b[3]-b[5]);
193 if(x1<0||x2<0||x3<0)
194 System.out.print("true ");
195 else
196 System.out.print("false ");
197 if(x1==0||x2==0||x3==0)
198 System.out.print("true ");
199 else
200 System.out.print("false ");
201 if(x1>0||x2>0||x3>0)
202 System.out.print("true");
203 else
204 System.out.print("false");*/
205 double a1=Math.sqrt((b[3]-b[1])*(b[3]-b[1])+(b[2]-b[0])*(b[2]-b[0]));
206 double d1=Math.sqrt((b[5]-b[1])*(b[5]-b[1])+(b[4]-b[0])*(b[4]-b[0]));
207 double c1=Math.sqrt((b[5]-b[3])*(b[5]-b[3])+(b[4]-b[2])*(b[4]-b[2]));
208 if(k1==k2||(b[3]-b[1])*(b[0]-b[4])-(b[1]-b[5])*(b[2]-b[0])==0||(b[0]-b[2]==0&&b[1]-b[3]==0)||(b[0]-b[4]==0&&b[1]-b[5]==0)||(b[2]-b[4]==0&&b[3]-b[5]==0)||(!((a+d>c&&Math.abs(a-d)<c)||(a+c>d&&Math.abs(a-c)<d)||(c+d>a&&Math.abs(c-d)<a))))
209 {
210 System.out.print("data error");
211 return;
212 }
213 else
214 {
215 if((c1*c1+d1*d1-a1*a1)<0||(d1*d1+c1*c1-a1*a1)<0||(a1*a1+d1*d1-c1*c1)<0)
216 System.out.print("true false false");
217 else
218 {
219 if((c1*c1+d1*d1-a1*a1)/2*d1*c1==0||(d1*d1+c1*c1-a1*a1)/2*d1*c1==0||(a1*a1+d1*d1-c1*c1)/2*d1*a1==0)
220 System.out.print("false true false");
221 if(((c1*c1+d1*d1-a1*a1)/2*d1*c1>0||(d1*d1+c1*c1-a1*a1)/2*d1*c1>0||(a1*a1+d1*d1-c1*c1)/2*d1*a1>0))
222 System.out.print("false false true");
223
224 }
225 }
226 }
227 }
228 }
229 if(s1.charAt(0)=='4')
230 {
231 String s2=s1.substring(2);
232 String s3=s2.replace(","," ");
233 String[]s4=s3.split(" ");
234 if(s4.length!=10)
235 System.out.println("wrong number of points");
236 else
237 {
238 double b1[]=new double[10];
239 for(j=0;j<10;j++)
240
241 b1[j]=Double.parseDouble(s4[j]);
242 if(b1[3]==b1[1]&&b1[2]==b1[0])
243 {
244 System.out.print("points coincide");
245 return;
246 }
247
248 double a=Math.sqrt((b1[9]-b1[7])*(b1[9]-b1[7])+(b1[8]-b1[6])*(b1[8]-b1[6]));
249 double d=Math.sqrt((b1[9]-b1[5])*(b1[9]-b1[5])+(b1[8]-b1[4])*(b1[8]-b1[4]));
250 double c=Math.sqrt((b1[7]-b1[5])*(b1[7]-b1[5])+(b1[6]-b1[4])*(b1[6]-b1[4]));
251 if(!((a+d>c&&Math.abs(a-d)<c)&&(a+c>d&&Math.abs(a-c)<d)&&(c+d>a&&Math.abs(c-d)<a)))
252 System.out.println("data error");
253 else
254 {
255 if(((b[1]-b[3])==(b[5]-b[7])&&(b[2]-b[0])==(b[6]-b[4])&&(b[7]-b[5])*b[4]-(b[6]-b[4])*b[5]==(b[3]-b[1])*b[0]-(b[2]-b[0])*b[1]))
256 // System.out.print("The point is on the edge of the triangle");
257 else if((b[1]-b[3])==(b[9]-b[7])&&(b[2]-b[0])==(b[6]-b[8])&&(b[7]-b[9])*b[8]-(b[6]-b[8])*b[9]==(b[3]-b[1])*b[0]-(b[2]-b[0])*b[1])
258 // System.out.print("The point is on the edge of the triangle");
259 else if((b[1]-b[3])==(b[7]-b[9])&&(b[2]-b[0])==(b[8]-b[6])&&(b[3]-b[1])*b[0]-(b[2]-b[0])*b[1]==(b[9]-b[7])*b[6]-(b[8]-b[6])*b[7])
260 //System.out.print("The point is on the edge of the triangle");
261 else
262 {
263 int count=0,count1=0,count2=0,count3=0;
264 if(b[0]==b[2]&&b[4]==b[6])
265 count1=0;
266 else if((b[3]-b[1])/(b[2]-b[0])==(b[7]-b[5])/(b[6]-b[4]))
267 count1=0;
268 if(b[0]==b[2]&&b[4]==b[8])
269 count2=0;
270 else if((b[3]-b[1])/(b[2]-b[0])==(b[9]-b[5])/(b[8]-b[4]))
271 count2=0;
272 if(b[0]==b[2]&&b[4]==b[8])
273 count2=0;
274 else if((b[3]-b[1])/(b[2]-b[0])==(b[9]-b[7])/(b[8]-b[6]))
275 count3=0;
276 double x1=0,y1=0,x2=0,y2=0,x3=0,y3=0,A1,B1,C1,A2,B2,C2,A3,B3,C3,A4,B4,C4;
277
278 double jd[]=new double[6];
279 int n=0;
280 if(b[2]!=b[0]&&b[4]!=b[6])
281 {
282 A1=b[1]-b[3];
283 B1=b[2]-b[0];
284 C1=(b[3]-b[1])*b[0]-(b[2]-b[0])*b[1];
285 A2=b[5]-b[7];
286 B2=b[6]-b[4];
287 C2=(b[7]-b[5])*b[4]-(b[6]-b[4])*b[5];
288 /* A3=b[5]-b[9];
289 B3=b[8]-b[4];
290 C3=(b[9]-b[5])*b[4]-(b[8]-b[4])*b[5];
291 A4=b[7]-b[9];
292 B4=b[8]-b[6];
293 C4=(b[9]-b[7])*b[6]-(b[8]-b[6])*b[7];*/
294 x1=(B1*C2-B2*C1)/(A1*B2-A2*B1);
295 y1=(A1*C2-A2*C1)/(B1*A2-B2*A1);
296 /* x2=(B1*C3-B3*C1)/(A1*B3-A3*B1);
297 y2=(A1*C3-A3*C1)/(B1*A3-B3*A1);
298 x3=(B1*C4-B4*C1)/(A1*B4-A4*B1);
299 y3=(A1*C4-A4*C1)/(B1*A4-B4*A1);*/
300
301 }
302 else if(b[2]!=b[0]&&b[4]==b[6])
303 {
304 x1=b[4];
305 y1=b[1]+((b[4]-b[0])*(b[3]-b[1])/(b[2]-b[0]));
306 }
307 else if(b[2]==b[0]&&b[4]!=b[6])
308 {
309 x1=b[4];
310 y1=b[5]+((b[0]-b[4])*(b[7]-b[5])/(b[6]-b[4]));
311 }
312 double max1,min1,max2,min2;
313 if(b[4]>b[8])
314 {
315 max1=b[4];
316 min1=b[8];
317 }
318 else
319 {
320 max1=b[8];
321 min1=b[4];
322 }
323 if(b[5]>b[9])
324 {
325 max2=b[5];
326 min2=b[9];
327 }
328 else
329 {
330 max2=b[9];
331 min2=b[5];
332 }
333 if((x1<max1&&x1>min1)||Math.abs(x1-max1)<0.000001||Math.abs(x1-min1)<0.000001)
334 {
335 if((y1<max2&&y1>min2)||Math.abs(y1-max2)<0.000001||Math.abs(y1-min2)<0.000001)
336 {
337 count1++;
338 jd[n]=x1;
339 n++;
340 jd[n]=x1;
341 n++;
342 }
343 }
344
345 if(b[2]!=b[0]&&b[4]!=b[8])
346 {
347 A1=b[1]-b[3];
348 B1=b[2]-b[0];
349 C1=(b[3]-b[1])*b[0]-(b[2]-b[0])*b[1];
350 /* A2=b[5]-b[7];
351 B2=b[6]-b[4];
352 C2=(b[7]-b[5])*b[4]-(b[6]-b[4])*b[5];*/
353 A3=b[5]-b[9];
354 B3=b[8]-b[4];
355 C3=(b[9]-b[5])*b[4]-(b[8]-b[4])*b[5];
356 /* A4=b[7]-b[9];
357 B4=b[8]-b[6];
358 C4=(b[9]-b[7])*b[6]-(b[8]-b[6])*b[7];*/
359 // x1=(B1*C2-B2*C1)/(A1*B2-A2*B1);
360 // y1=(A1*C2-A2*C1)/(B1*A2-B2*A1);
361 x2=(B1*C3-B3*C1)/(A1*B3-A3*B1);
362 y2=(A1*C3-A3*C1)/(B1*A3-B3*A1);
363 /* x3=(B1*C4-B4*C1)/(A1*B4-A4*B1);
364 y3=(A1*C4-A4*C1)/(B1*A4-B4*A1);*/
365
366 }
367 else if(b[2]!=b[0]&&b[4]==b[8])
368 {
369 x2=b[4];
370 y2=b[1]+((b[4]-b[0])*(b[3]-b[1])/(b[2]-b[0]));
371 }
372 else if(b[2]==b[0]&&b[4]!=b[6])
373 {
374 x2=b[0];
375 y2=b[5]+((b[0]-b[4])*(b[9]-b[5])/(b[8]-b[4]));
376 }
377 double max11,min11,max21,min21;
378 if(b[4]>b[8])
379 {
380 max11=b[4];
381 min11=b[8];
382 }
383 else
384 {
385 max11=b[8];
386 min11=b[4];
387 }
388 if(b[5]>b[9])
389 {
390 max21=b[5];
391 min21=b[9];
392 }
393 else
394 {
395 max21=b[9];
396 min21=b[5];
397 }
398 if((x2<max11&&x2>min11)||Math.abs(x2-max11)<0.000001||Math.abs(x2-min11)<0.000001)
399 {
400 if((y2<max21&&y2>min21)||Math.abs(y2-max21)<0.000001||Math.abs(y2-min21)<0.000001)
401 {
402 count2++;
403 jd[n]=x2;
404 n++;
405 jd[n]=y2;
406 n++;
407 }
408 }
409
410 if(b[2]!=b[0]&&b[6]!=b[8])
411 {
412 A1=b[1]-b[3];
413 B1=b[2]-b[0];
414 C1=(b[3]-b[1])*b[0]-(b[2]-b[0])*b[1];
415 /* A2=b[5]-b[7];
416 B2=b[6]-b[4];
417 C2=(b[7]-b[5])*b[4]-(b[6]-b[4])*b[5];*/
418 /* A3=b[5]-b[9];
419 B3=b[8]-b[4];
420 C3=(b[9]-b[5])*b[4]-(b[8]-b[4])*b[5];*/
421 A4=b[7]-b[9];
422 B4=b[8]-b[6];
423 C4=(b[9]-b[7])*b[6]-(b[8]-b[6])*b[7];
424 // x1=(B1*C2-B2*C1)/(A1*B2-A2*B1);
425 // y1=(A1*C2-A2*C1)/(B1*A2-B2*A1);
426 // x2=(B1*C3-B3*C1)/(A1*B3-A3*B1);
427 //y2=(A1*C3-A3*C1)/(B1*A3-B3*A1);
428 x3=(B1*C4-B4*C1)/(A1*B4-A4*B1);
429 y3=(A1*C4-A4*C1)/(B1*A4-B4*A1);
430
431 }
432 else if(b[2]!=b[0]&&b[6]==b[8])
433 {
434 x3=b[6];
435 y3=b[1]+((b[6]-b[0])*(b[3]-b[1])/(b[2]-b[0]));
436 }
437 else if(b[2]==b[0]&&b[6]!=b[8])
438 {
439 x3=b[0];
440 y3=b[7]+((b[0]-b[6])*(b[9]-b[7])/(b[8]-b[6]));
441 }
442 double max111,min111,max211,min211;
443 if(b[6]>b[8])
444 {
445 max111=b[6];
446 min111=b[8];
447 }
448 else
449 {
450 max111=b[8];
451 min111=b[6];
452 }
453 if(b[7]>b[9])
454 {
455 max211=b[7];
456 min211=b[9];
457 }
458 else
459 {
460 max211=b[9];
461 min211=b[7];
462 }
463 if((x3<max111&&x3>min111)||Math.abs(x3-max111)<0.000001||Math.abs(x3-min111)<0.000001)
464 {
465 if((y3<max211&&y3>min211)||Math.abs(y3-max211)<0.000001||Math.abs(y3-min211)<0.000001)
466 {
467 count3++;
468 jd[n]=x3;
469 n++;
470 jd[n]=y3;
471 n++;
472 }
473
474 }
475 count=count1+count2+count3;
476 // if(count<2)
477 System.out.print(1);
478
479 // else
480 // {
481 // System.out.print(count1+" "+count2+" "+count3);
482 // }
483 }
484 }
485
486
487 }
488 }
489
490 if(s1.charAt(0)=='5')
491 {
492 String s2=s1.substring(2);
493 String s3=s2.replace(","," ");
494 String[]s4=s3.split(" ");
495 if(s4.length!=8)
496 System.out.println("wrong number of points");
497 else
498 {
499 double b1[]=new double[10];
500 for(j=0;j<8;j++)
501
502 b1[j]=Double.parseDouble(s4[j]);
503 double a=Math.sqrt((b1[7]-b1[3])*(b1[7]-b1[3])+(b1[6]-b1[2])*(b1[6]-b1[2]));
504 double d=Math.sqrt((b1[7]-b1[5])*(b1[7]-b1[5])+(b1[6]-b1[4])*(b1[6]-b1[4]));
505 double c=Math.sqrt((b1[5]-b1[3])*(b1[5]-b1[3])+(b1[4]-b1[2])*(b1[4]-b1[2]));
506 if(!((a+d>c&&Math.abs(a-d)<c)||(a+c>d&&Math.abs(a-c)<d)||(c+d>a&&Math.abs(c-d)<a)))
507 System.out.println("data error");
508 else
509 {
510 double s=0,s7=0,s5=0,s6=0,s8;
511 s=(b1[2]*b1[5]-b1[2]*b1[7]+b1[4]*b1[7]-b1[4]*b1[3]+b1[6]*b1[3]-b1[4]*b1[5]);
512 s7=(b1[0]*b1[3]-b1[0]*b1[5]+b1[2]*b1[5]-b1[2]*b1[1]+b1[4]*b1[1]-b1[3]*b1[2]);
513 s5=(b1[0]*b1[3]-b1[0]*b1[7]+b1[2]*b1[7]-b1[2]*b1[1]+b1[6]*b1[1]-b1[3]*b1[2]);
514 s6=(b1[0]*b1[7]-b1[0]*b1[5]+b1[6]*b1[5]-b1[6]*b1[1]+b1[4]*b1[1]-b1[7]*b1[6]);
515 s8=s5+s6+s7;
516 //if(s==s8)
517 //System.out.println("in the triangle");
518 if(s7==0||s5==0||s6==0)
519 System.out.println("on the triangle");
520 else
521 {
522 if(s>s7+s5+s6)
523 System.out.println("outof the triangle");
524 else
525 System.out.println("in the triangle");
526 }
527 }
528 }
529 }
530 }
531 }
532 }
533 }
534 }
踩坑心得：这道题是本次大作业失分最严重的一道题。首先是对于错误输入情况的判断，在沿用了上一道题的代码并加上了一些后仍有测试点过不了。这道题需要输出的数据若小数点后
超过六位，只保留小数点后六位，多余部分采用四舍五入规则进到最低位。小数点后若不足六位，按原位显示，不必补齐。这一要求开始挺困扰我的。后来去网上学了一下后，使用以下
代码才得以解决。对于前三个测试点题目相对较容易理解，但总有一两个测试点过不了。后两个测试点相对较难理解，特别是第四个测试点，在用我自己的理解写好代码后仍然过不了。
if((C*1e6)%10!=0)
System.out.print(String.format("%.6f",C)+" ");
else
System.out.print(C+" ");
改进建议：由生成的圈复杂图可知，本道题的复杂度非常高，而且需要重复写的代码非常多，由此可见类的重要性。所以下次写此类题目我会采用类写。还有通过这道题不理想的得分，
我觉得自己还应该加强Java的相关学习，平时可以多听听网课，写写代码，争取在下一次作业拿一个较理想的分。
总结：通过这道题，我学会了控制小数点后几位的操作，这对于我以后写题目很有帮助。还有就是加深了对正则表达式的学习。当然也暴露出很多不足，对于一些较复杂的问题，没有
办法很好的解决，考虑问题有时候会不全面，导致每个点都有过不了的测试点。
三.总结
综合来看，这三次大作业难度最大的是第三次大作业，而第三次大作业难度最大的又是第三题，这也是所有题目中得分最低的题目。今后应多尝试写这种情况复杂，需要多重考虑的题目。
还有一个问题就是所有题目复杂度都偏高，我觉得要解决这个问题除了把一个类拆分成多个类，把一个方法拆分成多个方法，还可以下意识的减少if-else的使用。
浙公网安备 33010602011771号