PTA前三次大作业总结
一、前言
1、知识点
（1）第一次作业
7-1、考查输入输出，选择结构，逻辑操作符
7-2、考查输入输出
7-3、考查输入输出，循环结构，一维数组
7-4、考查输入输出，选择结构，逻辑操作符
7-5、考查输入输出，选择结构，逻辑操作符
7-6、考查输入输出，字符串类型，选择结构，逻辑操作符
7-7、考查输入输出，选择结构，逻辑操作符
7-8、考查输入输出，选择结构，逻辑操作符
7-9、考查输入输出，字符串类型，选择结构，循环结构，逻辑操作符
（2）第二次作业
7-1、考查输入输出，选择结构，循环结构，字符串类型，从字符串中获取字符
7-2、考查输入输出，选择结构，循环结构，字符串类型，从字符串中获取字符，获得子字符串，逻辑操作符
7-3、考查输入输出，字符串类型，选择结构，循环结构
（3）第三次作业
7-1、考查正则表达式，选择结构，字符串类型，从字符串中获取字符，类型转换
7-2、考查正则表达式，选择结构，循环结构，逻辑操作符，字符串类型，从字符串中获取字符，类型转换，类和对象的建立
7-3、考查正则表达式，选择结构，循环结构，逻辑操作符，字符串类型，从字符串中获取字符，类型转换，类和对象的建立
2、题量及难度
（1）第一次作业
题量相对较多，难度都相对简单，比较基础
（2）第二次作业
题量相对较少，7-1和7-2难度相对简单，7-3难度中等
（3）第三次作业
题量相对较少，7-1难度中等，7-2和7-3难度相对较高
二、设计与分析
1、第一次作业
7-3、奇数求和
计算一个数列中所有奇数的和。
输入格式:
十个整数，以空格分隔。例如：1 2 3 4 5 6 7 8 9 0。
输出格式:
输入数列中所有奇数之和。例如：25。
输入样例:
在这里给出一组输入。例如：
1 2 3 4 5 6 7 8 9 0
输出样例:
在这里给出相应的输出。例如：
25
源码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
int i,s=0;
int[] a = new int[10];
for(i=0;i<a.length;i++)
{
a[i] = input.nextInt();
if(a[i]%2!=0)
{
s+=a[i];
}
}
System.out.println(s);
}
}
分析：
1、创建数组，将输入的十个整数存到数组中。
2、遍历数组，找出数组中的所有奇数。
3、将奇数累加，并输出结果。
7-5 、游戏角色选择
一款网游中包括4个种族：人类、精灵、兽人、暗精灵，每个种族包含三种角色：战士、法师、射手。玩家新建人物时需要选择种族和角色。请编写角色选择程序。
输入格式:
两个整数：游戏种族、角色的选项，以空格分隔。例如：1 2。
种族选项设定为：1、人类 2、精灵 3、兽人 4、暗精灵
角色选项设定为：1、战士 2、法师 3、射手
输出格式:
所选择的种族、角色的名称，以空格分隔。例如：人类 法师
若输入数值超出选项范围，输出“Wrong Format”
输入样例1:
在这里给出一组输入。例如：
1 2
输出样例1:
在这里给出相应的输出。例如：
人类 法师
输入样例2:
在这里给出一组输入。例如：
1 6
输出样例2:
在这里给出相应的输出。例如：
Wrong Format
源码：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
int a = input.nextInt();
int b = input.nextInt();
if(a>=1&&a<=4&b>=1&&b<=4)
{
switch(a)
{
case 1:System.out.printf("人类 ");
break;
case 2:System.out.printf("精灵 ");
break;
case 3:System.out.printf("兽人 ");
break;
case 4:System.out.printf("暗精灵 ");
break;
}
switch(b)
{
case 1:System.out.printf("战士");
break;
case 2:System.out.printf("法师");
break;
case 3:System.out.printf("射手");
break;
}
}
else
{
System.out.printf("Wrong Format");
}
}
}
分析：
1、先用变量a，b获取用户输入的数字。
2、使用if条件语句判断输入是否符合要求，如果满足要求进入下一步，否则输出"Wrong Format"。
3、再使用switch语句，根据数据选择输出相关内容。
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
源码：
import java.util.Scanner;
public class Main{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
float n = input.nextFloat();
float lastGuess = input.nextFloat();
if(n<0||lastGuess<=0)
{
System.out.println("Wrong Format");
}
else
{
float nextGuess;
nextGuess = (lastGuess+n/lastGuess)/2;
while(Math.abs(nextGuess-lastGuess)>=0.00001)
{
lastGuess = nextGuess;
nextGuess = (lastGuess+n/lastGuess)/2;
}
System.out.println(lastGuess);
}
}
}
分析：
1、首先给nextGuess赋值为nextGuess = (lastGuess+n/lastGuess)/2。
2、判断nextGuess与lastGuess的差值是否小于0.00001，如果不满足则进入下一步，否则输出。
3、进入循环体令lastGuess=nextGuess和nextGuess = (lastGuess+n/lastGuess)/2。
2、第二次作业
7-2 串口字符解析
RS232是串口常用的通信协议，在异步通信模式下，串口可以一次发送58位数据，收发双方之间没有数据发送时线路维持高电平，相当于接收方持续收到数据“1”（称为空闲位），发送方有数据发送时，会在有效数据（58位，具体位数由通信双方提前设置）前加上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
源码：
import java.util.Scanner;
public class Main
{
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
String data = input.next();
boolean flag = false;
int i,j,s=0;
int t=0;
for(i=0;i<data.length();i++)
{
if(data.charAt(i)=='0')
{
flag = true;
}
}
if(data.length()<11)
{
System.out.println("null data");
}
else
{
if(flag==true)
{
for(i=0;i<data.length();i++)
{
if(data.charAt(i)=='0'&&data.length()-i>10)
{
for(j=i+1;j<i+9;j++)
{
if(data.charAt(j)=='1')
{
s++;
}
}
if(s%2==0)
{
if(data.charAt(i+9)=='1'&&data.charAt(i+10)=='1')
{
t++;
System.out.println(t+":"+data.substring(i+1, i+9));
i+=10;
}
else if(data.charAt(i+9)!='1'&&data.charAt(i+10)=='1')
{
t++;
System.out.println(t+":"+"parity check error");
i+=10;
}
else if(data.charAt(i+9)=='1'&&data.charAt(i+10)!='1')
{
t++;
System.out.println(t+":"+"validate error");
i+=10;
}
else
{
t++;
System.out.println(t+":"+"validate error");
i+=10;
}
}
else
{
if(data.charAt(i+9)=='0'&&data.charAt(i+10)=='1')
{
t++;
System.out.println(t+":"+data.substring(i+1, i+9));
i+=10;
}
else if(data.charAt(i+9)!='0'&&data.charAt(i+10)=='1')
{
t++;
System.out.println(t+":"+"parity check error");
i+=10;
}
else if(data.charAt(i+9)=='0'&&data.charAt(i+10)!='1')
{
t++;
System.out.println(t+":"+"validate error");
i+=10;
}
else
{
t++;
System.out.println(t+":"+"validate error");
i+=10;
}
}
}
}
}
else
{
System.out.println("null data");
}
}
}
}
分析：
在分析之前我想说明一下，我本身的代码还不够完善，有几个测试点未过，还需要进一步改进。
将二进制数据流存储在字符串类型中，通过charAt()来访问每一位字符，因此设置了一个循环。然后在循环中，
主要通过if条件语句来判断各种情况。就难度来讲，我认为这道题还是中等的难度，主要是题目表达的意思有
点难理解。想要做好这道题目，关键是将题目看懂，逐步分析判断每种情况，完成相应的输出。
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
源码：
import java.util.Scanner;
public class Main {
public static void main(String[] args)
{
Input input = new Input();
input.legal();
}
}
class Input
{
Scanner in = new Scanner(System.in);
String spot = in.nextLine();
String a = "(-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String b = "(-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*))+";
public void legal()
{
if(spot.matches(a))
{
Distance distance = new Distance();
distance.calculate(spot);
}
else if(spot.matches(b))
{
System.out.println("wrong number of points");
}
else
{
System.out.println("Wrong Format");
}
}
}
class Distance
{
public void calculate(String spot)
{
double result;
int t = 0;
int m = 0;
String[] arr = new String[4];
for(int i=0;i<spot.length();i++)
{
if(spot.charAt(i)==','||spot.charAt(i)==' ')
{
arr[t] = spot.substring(m,i);
m = i+1;
t++;
}
}
arr[t]= spot.substring(m,spot.length());
double x1 = Double.parseDouble(arr[0]);
double y1 = Double.parseDouble(arr[1]);
double x2 = Double.parseDouble(arr[2]);
double y2 = Double.parseDouble(arr[3]);
double x = Math.pow(x1-x2,2);
double y = Math.pow(y1-y2,2);
result = Math.sqrt(x+y);
System.out.println(result);
}
}
分析：
本题难在对输入内容的格式进行判断，主要通过正则表达式来完成。主要部分是写浮点数的正则表达式，我写的一种浮点数正则表达式：
(-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)
解决了输入格式判断的问题，那么接下来的问题就简单了。首先我写了一个输入类，有一个判断输入合法性的方法，用来判断输入然后做出相应输出。接着创建一个距离类，用来计算两点间距离。通过遍历输入的字符串，将每个坐标存入一个字符串数组，再将字符串数组通过Double.parseDouble（）转化为浮点数字符串，最后 通过相关计算完成想要输出。
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:
选项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
源码：
import java.util.Scanner;
public class Main {
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);
String spot = input.nextLine();
Output output = new Output();
output.legal(spot);
}
}
class Output
{
Switch swich = new Switch();
Calculate calculate = new Calculate();
public void legal(String spot)
{
String s1 = "[1][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s2 = "[2][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s3 = "[3][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s4 = "[4][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s5 = "[5][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String a = "[1][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*))+";
String b1 = "[23][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String b2 = "[23][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*))+";
String c1 = "[45][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){1,3}";
String c2 = "[45][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){4,}";
if(spot.matches(s1))
{
double[] xy = new double[4];
swich.StringtoDouble(4, spot, xy);
calculate.slope(xy);
}
else if(spot.matches(s2))
{
double[] xy = new double[6];
swich.StringtoDouble(6, spot, xy);
calculate.distance(xy);
}
else if(spot.matches(s3))
{
double[] xy = new double[6];
swich.StringtoDouble(6, spot, xy);
calculate.collinear(xy);
}
else if(spot.matches(s4))
{
double[] xy = new double[8];
swich.StringtoDouble(8, spot, xy);
calculate.parallel(xy);
}
else if(spot.matches(s5))
{
double[] xy = new double[8];
swich.StringtoDouble(8, spot, xy);
calculate.intersection(xy);
}
else if(spot.matches(a)||spot.matches(b1)||spot.matches(b2)||spot.matches(c1)||spot.matches(c2))
{
System.out.println("wrong number of points");
}
else
{
System.out.println("Wrong Format");
}
}
}
class Switch
{
public void StringtoDouble(int num,String spot,double xy[])
{
String[] arr = new String[num];
int m = 2;
int t = 0;
for(int i=2;i<spot.length();i++)
{
if(spot.charAt(i)==','||spot.charAt(i)==' ')
{
arr[t] = spot.substring(m,i);
m = i+1;
t++;
}
}
arr[t]= spot.substring(m,spot.length());
for(int i=0;i<num;i++)
{
xy[i] = Double.parseDouble(arr[i]);
}
}
}
class Calculate
{
public void slope(double xy[])
{
if(xy[0]==xy[2]&&xy[1]==xy[3])
{
System.out.println("points coincide");
}
else
{
if(xy[0]==xy[2])
{
System.out.println("Slope does not exist");
}
else
{
double result = (xy[1]-xy[3])/(xy[0]-xy[2]);
System.out.println(result);
}
}
}
public void distance(double xy[])
{
if(xy[0]==xy[2]&&xy[1]==xy[3]||xy[0]==xy[2]&&xy[4]==xy[5]||xy[2]==xy[4]&&xy[3]==xy[5])
{
System.out.println("points coincide");
}
else
{
double a = xy[4]-xy[2];
double b = xy[5]-xy[3];
double m = Math.abs(b*xy[0]-a*xy[1]+xy[3]*a-xy[2]*b);
double n = Math.sqrt(a*a+b*b);
double result = m/n;
System.out.println(result);
}
}
public void collinear(double xy[])
{
if(xy[0]==xy[2]&&xy[1]==xy[3]||xy[0]==xy[2]&&xy[4]==xy[5]||xy[2]==xy[4]&&xy[3]==xy[5])
{
System.out.println("points coincide");
}
else
{
boolean flag = false;
if(xy[0]==xy[2]&&xy[0]==xy[4])
{
flag = true;
}
else
{
double k1=(xy[1]-xy[5])/(xy[0]-xy[4]);
double k2=(xy[3]-xy[5])/(xy[2]-xy[4]);
if(k1==k2)
{
flag = true;
}
}
System.out.println(flag);
}
}
public void parallel(double xy[])
{
if(xy[0]==xy[2]&&xy[1]==xy[3]||xy[0]==xy[4]&&xy[1]==xy[5]||xy[0]==xy[6]&&xy[1]==xy[7]||xy[2]==xy[4]&&xy[3]==xy[5]||xy[2]==xy[6]&&xy[3]==xy[7]||xy[4]==xy[6]&&xy[5]==xy[7])
{
System.out.println("points coincide");
}
else
{
boolean flag = false;
if(xy[1]==xy[3]&&xy[5]==xy[7])
{
flag = true;
}
else
{
double k1=(xy[1]-xy[3])/(xy[0]-xy[2]);
double k2=(xy[5]-xy[7])/(xy[4]-xy[6]);
if(k1==k2)
{
flag = true;
}
}
System.out.println(flag);
}
}
public void intersection(double xy[])
{
if(xy[0]==xy[2]&&xy[1]==xy[3]||xy[0]==xy[4]&&xy[1]==xy[5]||xy[0]==xy[6]&&xy[1]==xy[7]||xy[2]==xy[4]&&xy[3]==xy[5]||xy[2]==xy[6]&&xy[3]==xy[7]||xy[4]==xy[6]&&xy[5]==xy[7])
{
System.out.println("points coincide");
}
else
{
boolean flag = false;
double k1,k2;
if(xy[1]==xy[3]&&xy[5]==xy[7])
{
flag = true;
}
else
{
k1=(xy[1]-xy[3])/(xy[0]-xy[2]);
k2=(xy[5]-xy[7])/(xy[4]-xy[6]);
if(k1==k2)
{
flag = true;
}
}
if(flag==true)
{
System.out.println("is parallel lines,have no intersection point");
}
else
{
double A,B,C,D,E,F,x,y;
A = xy[3]-xy[1];
B = xy[0]-xy[2];
C = -(xy[0]*xy[3]+xy[2]*xy[1]);
D = xy[7]-xy[5];
E = xy[4]-xy[6];
F = -(xy[4]*xy[7]+xy[6]*xy[5]);
x = (C*E-B*F)/(A*E-B*D);
y = (A*F-C*D)/(A*E-B*D);
System.out.print(x+","+y+" ");
if(((x>=xy[0]&&x<=xy[2]||x<=xy[0]&&x>=xy[2])||(x>=xy[4]&&x<=xy[6]||x<=xy[4]&&x>=xy[6]))&&((y>=xy[1]&&y<=xy[3]||y<=xy[1]&&y>=xy[3])||(y>=xy[5]&&y<=xy[7]||y<=xy[5]&&y>=xy[7])))
{
System.out.println(true);
}
else
{
System.out.println(false);
}
}
}
}
}
分析：
本题我自己的代码还存在一些缺陷，有些测试的还未通过，对问题考虑的不是很全面。
首先我们先要写出每个选项的方法，方法的设计根据相关的数学知识。本题涉及到点与点的关系，点与线的关系以及线与线的关系。计算点到直线的距离，可以先通过两点将直线方程表达出来，在将令一个点带入点到直线的距离公式即可求出结果。判断三个点是否在同一在直线上，我们首先的考虑每两个点之间的斜率是否存在。如果两点横坐标相等，则这两点斜率不存在；若两点之间斜率都存在，计算两条线的斜率是否相等，即可判断三点是否共线。判断两条直线是否平行，首先我们同样先考虑两条直线斜率是否存在，都不存在则平行；其次在判断两条直线斜率是否相等，相等则平行。求两条直线的交点坐标，首先得将两条直线的方程写出来，通过相关计算得出最终结果。在输出方面我们不仅得考虑输入格式问题，还得考虑两点是否重合的问题，解决这些问题基本就能完成最终的输出。
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"，
输入样例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
源码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input = new Scanner(System.in);
String spot = input.nextLine();
Output output = new Output();
output.legal(spot);
}
}
class Output
{
public void legal(String spot)
{
String s1 = "[1][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s2 = "[2][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s3 = "[3][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)";
String s4 = "[4][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){4}";
String s5 = "[5][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){3}";
String a = "[123][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){0,2}";
String b = "[123][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){3,}";
String c = "[4][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){0,4}";
String d = "[4][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){5,}";
String e = "[5][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){0,3}";
String f = "[5][:](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)([ ](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)[,](-?|\\+?)([1-9][\\d]*\\.[\\d]+|[0]\\.[\\d]+|[0]|[1-9][\\d]*)){4,}";
if(spot.matches(s1))
{
Switch s = new Switch();
double[] x = new double[3];
double[] y = new double[3];
Point[] ppp = new Point[3];
s.StringtoDouble(6, spot, x, y);
s.toPoint(ppp, x, y);
Triangle triangle = new Triangle();
triangle.l1 = new Line(ppp[0],ppp[1]);
triangle.l2 = new Line(ppp[1],ppp[2]);
triangle.l3 = new Line(ppp[2],ppp[0]);
if((ppp[0].getx()==ppp[1].getx()&&ppp[0].gety()==ppp[1].gety()||ppp[0].getx()==ppp[2].getx()&&ppp[0].gety()==ppp[2].gety()||ppp[2].getx()==ppp[1].getx()&&ppp[2].gety()==ppp[1].gety()))
{
System.out.println("data error");
}
else if(ppp[0].getx()==ppp[1].getx()&&ppp[0].getx()==ppp[2].getx())
{
System.out.println("data error");
}
else if(triangle.l1.Slope()==triangle.l2.Slope())
{
System.out.println("data error");
}
else
{
System.out.println(triangle.isosceles()+" "+triangle.equilateral());
}
}
else if(spot.matches(s2))
{
Switch s = new Switch();
double[] x = new double[3];
double[] y = new double[3];
Point[] ppp = new Point[3];
s.StringtoDouble(6, spot, x, y);
s.toPoint(ppp, x, y);
Triangle triangle = new Triangle();
triangle.l1 = new Line(ppp[0],ppp[1]);
triangle.l2 = new Line(ppp[1],ppp[2]);
triangle.l3 = new Line(ppp[2],ppp[0]);
if((ppp[0].getx()==ppp[1].getx()&&ppp[0].gety()==ppp[1].gety()||ppp[0].getx()==ppp[2].getx()&&ppp[0].gety()==ppp[2].gety()||ppp[2].getx()==ppp[1].getx()&&ppp[2].gety()==ppp[1].gety()))
{
System.out.println("data error");
}
else if(ppp[0].getx()==ppp[1].getx()&&ppp[0].getx()==ppp[2].getx())
{
System.out.println("data error");
}
else if(triangle.l1.Slope()==triangle.l2.Slope())
{
System.out.println("data error");
}
else
{
System.out.println((float)triangle.perimeter()+" "+(float)triangle.area()+" "+(float)triangle.focus().getx()+","+(float)triangle.focus().gety());
}
}
else if(spot.matches(s3))
{
Switch s = new Switch();
double[] x = new double[3];
double[] y = new double[3];
Point[] ppp = new Point[3];
s.StringtoDouble(6, spot, x, y);
s.toPoint(ppp, x, y);
Triangle triangle = new Triangle();
triangle.l1 = new Line(ppp[0],ppp[1]);
triangle.l2 = new Line(ppp[1],ppp[2]);
triangle.l3 = new Line(ppp[2],ppp[0]);
if((ppp[0].getx()==ppp[1].getx()&&ppp[0].gety()==ppp[1].gety()||ppp[0].getx()==ppp[2].getx()&&ppp[0].gety()==ppp[2].gety()||ppp[2].getx()==ppp[1].getx()&&ppp[2].gety()==ppp[1].gety()))
{
System.out.println("data error");
}
else if(ppp[0].getx()==ppp[1].getx()&&ppp[0].getx()==ppp[2].getx())
{
System.out.println("data error");
}
else if(triangle.l1.Slope()==triangle.l2.Slope())
{
System.out.println("data error");
}
else
{
System.out.println(triangle.Obtuseangle()+" "+triangle.rightangle()+" "+triangle.acuteangle());
}
}
else if(spot.matches(s4))
{
Switch s = new Switch();
double[] x = new double[5];
double[] y = new double[5];
Point[] ppp = new Point[5];
s.StringtoDouble(10, spot, x, y);
s.toPoint(ppp, x, y);
Triangle triangle = new Triangle();
triangle.l1 = new Line(ppp[2],ppp[3]);
triangle.l2 = new Line(ppp[3],ppp[4]);
triangle.l3 = new Line(ppp[4],ppp[2]);
Point p = new Point(ppp[0].getx(),ppp[0].gety());
Point q = new Point(ppp[1].getx(),ppp[1].gety());
if(p.getx()==q.getx()&&p.gety()==q.gety())
{
System.out.println("points coincide");
}
else if((ppp[2].getx()==ppp[3].getx()&&ppp[2].gety()==ppp[3].gety()||ppp[3].getx()==ppp[4].getx()&&ppp[3].gety()==ppp[4].gety()||ppp[4].getx()==ppp[2].getx()&&ppp[4].gety()==ppp[2].gety()))
{
System.out.println("data error");
}
else if(ppp[3].getx()==ppp[4].getx()&&ppp[0].getx()==ppp[2].getx())
{
System.out.println("data error");
}
else if(triangle.l1.Slope()==triangle.l2.Slope())
{
System.out.println("data error");
}
else
{
}
}
else if(spot.matches(s5))
{
Switch s = new Switch();
double[] x = new double[4];
double[] y = new double[4];
Point[] ppp = new Point[4];
s.StringtoDouble(8, spot, x, y);
s.toPoint(ppp, x, y);
Triangle triangle = new Triangle();
triangle.l1 = new Line(ppp[1],ppp[2]);
triangle.l2 = new Line(ppp[2],ppp[3]);
triangle.l3 = new Line(ppp[3],ppp[1]);
Point p = new Point(ppp[0].getx(),ppp[0].gety());
Point[] point = new Point[3];
point[0] = new Point(ppp[1].getx(),ppp[1].gety());
point[1] = new Point(ppp[2].getx(),ppp[2].gety());
point[2] = new Point(ppp[3].getx(),ppp[3].gety());
if((ppp[1].getx()==ppp[2].getx()&&ppp[1].gety()==ppp[2].gety()||ppp[2].getx()==ppp[3].getx()&&ppp[2].gety()==ppp[3].gety()||ppp[3].getx()==ppp[1].getx()&&ppp[3].gety()==ppp[1].gety()))
{
System.out.println("data error");
}
else if(ppp[3].getx()==ppp[1].getx()&&ppp[0].getx()==ppp[2].getx())
{
System.out.println("data error");
}
else if(triangle.l1.Slope()==triangle.l2.Slope())
{
System.out.println("data error");
}
else
{
int count = triangle.raymethod(p, point, 3);
if(count==0)
{
System.out.println("outof triangle");
}
else if(count==1)
{
System.out.println("in the triangle");
}
else
{
System.out.println("on the triangle");
}
}
}
else if(spot.matches(a)||spot.matches(b)||spot.matches(c)||spot.matches(d)||spot.matches(e)||spot.matches(f))
{
System.out.println("wrong number of points");
}
else
{
System.out.println("Wrong Format");
}
}
}
class Switch
{
public void StringtoDouble(int num,String spot,double x[],double y[])
{
String[] arr = new String[num];
double[] xy = new double[num];
int m = 2;
int t = 0;
for(int i=2;i<spot.length();i++)
{
if(spot.charAt(i)==','||spot.charAt(i)==' ')
{
arr[t] = spot.substring(m,i);
m = i+1;
t++;
}
}
arr[t]= spot.substring(m,spot.length());
for(int i=0;i<num;i++)
{
xy[i] = Double.parseDouble(arr[i]);
}
int n = 0;
int r = 0;
for(int i=0;i<xy.length;i++)
{
if(i%2==0)
{
x[n] = xy[i];
n++;
}
else
{
y[r] = xy[i];
r++;
}
}
}
public void toPoint(Point a[],double x[],double y[])
{
for(int i=0;i<a.length;i++)
{
a[i] = new Point(x[i],y[i]);
}
}
}
class Point
{
private double x,y;
Point(double x,double y)
{
this.x = x;
this.y = y;
}
public void setx(double x)
{
this.x = x;
}
public double getx()
{
return x;
}
public void sety(double y)
{
this.y = y;
}
public double gety()
{
return y;
}
}
class Line
{
Point p1;
Point p2;
Line(Point p1,Point p2)
{
this.p1 = p1;
this.p2 = p2;
}
public double sidelength()
{
double x = Math.pow(p1.getx()-p2.getx(), 2);
double y = Math.pow(p1.gety()-p2.gety(), 2);
double result = Math.sqrt(x+y);
return result;
}
public double Slope()
{
double k = (p1.gety()-p2.gety())/(p1.getx()-p2.gety());
return k;
}
}
class Triangle
{
Line l1;
Line l2;
Line l3;
public boolean isosceles()//等腰
{
if(l1.sidelength()==l2.sidelength()||l1.sidelength()==l3.sidelength()||l3.sidelength()==l2.sidelength())
{
return true;
}
else
{
return false;
}
}
public boolean equilateral()//等边
{
if(l1.sidelength()==l2.sidelength()&&l1.sidelength()==l3.sidelength())
{
return true;
}
else
{
return false;
}
}
public double perimeter()//周长
{
double c = l1.sidelength()+l2.sidelength()+l3.sidelength();
return c;
}
public double area()//面积
{
double p = (l1.sidelength()+l2.sidelength()+l3.sidelength())/2;
double m = p*(p-l1.sidelength())*(p-l2.sidelength())*(p-l3.sidelength());
double s =Math.sqrt(m);
return s;
}
public Point focus()//重心坐标
{
double x = (l1.p1.getx()+l2.p1.getx()+l3.p1.getx())/3;
double y = (l1.p1.gety()+l2.p1.gety()+l3.p1.gety())/3;
Point m = new Point(x,y);
return m;
}
public boolean Obtuseangle()//钝角
{
double a = Math.pow(l1.sidelength(), 2);
double b = Math.pow(l2.sidelength(), 2);
double c = Math.pow(l3.sidelength(), 2);
if(a+b>c+0.00001||a+c>b+0.00001||b+c>a+0.00001)
{
return true;
}
else
{
return false;
}
}
public boolean rightangle()//直角
{
double a = Math.pow(l1.sidelength(), 2);
double b = Math.pow(l2.sidelength(), 2);
double c = Math.pow(l3.sidelength(), 2);
if(a+b<c+0.00001&&a+b>c-0.00001||a+c<b+0.00001&&a+c>b-0.00001||b+c<a+0.00001&&b+c>a-0.00001)
{
return true;
}
else
{
return false;
}
}
public boolean acuteangle()//锐角
{
double a = Math.pow(l1.sidelength(), 2);
double b = Math.pow(l2.sidelength(), 2);
double c = Math.pow(l3.sidelength(), 2);
if(a+b<c-0.00001&&a+c<b-0.00001&&b+c<a-0.00001)
{
return true;
}
else
{
return false;
}
}
public int raymethod(Point p,Point point[],int num)//射线法
{
int s=0;
for(int i=0;i<num;i++)
{
Point m = point[i];
Point n = point[(i+1)%num];
if(m.gety()==n.gety()||p.gety()>Math.max(m.gety(),n.gety())||p.gety()<Math.min(m.gety(), n.gety()))
{
if(p.gety()==m.gety()&&p.getx()<Math.max(m.getx(), n.getx())&&p.getx()>Math.min(m.getx(), n.getx()))
{
s=100;
break;
}
continue;
}
double x = (p.gety()-m.gety())*(n.getx()-m.getx())/(n.gety()-m.gety())+m.getx();
if(x>p.getx())
{
s++;
}
if(x==p.getx())
{
s=100;
break;
}
}
if(s==0||s==2)
{
return 0;
}
else if(s==1)
{
return 1;
}
else
{
return 3;
}
}
}
分析：
从前两题的基础上，本题涉及到点、线、三角形相关内容，由此我们可以设计Point、Line、Triangle三个类。其中Point类只需存放点的横纵坐标。Line类包括两个Point类属性，以及计算斜率和两点距离的方法。Triangle类需要存放三个Line类，以及题目出现的各种各样的方法。我们还得设计一个转换类，用来将输入的字符串的坐标提取字符串数组中，然后将字符数组转化为浮点数数组。创建一个输出类，用正则表达式来匹配各种输入格式，在用条件语句作出判断，完成相应输出。在三角形类中判断是否是等腰三角形、等边三角形，需要判断三条边的长度是否相等。输出周长、面积、重心坐标，周长和面积可以通过边长来求得；重心坐标将三点坐标相加除以三即可。判断三角形是钝角、直角还是锐角三角形，根据三边边长得平方关系得到。判断点在三角形内部还是外部，可以使用射线法来做。
三、踩坑心得
1、没有搞清输出格式，例如变量为double类型，但结果要求float类型。
2、通过两边平方和与第三边的关系来判断三角形类型，没有考虑浮点数间的误差，导致一些测试点没有通过。由于三角形的边可以为无理数，而输入的是浮点数，所以边的平方和关系可以有10的-5次方的误差。
3、字符串提取一个字符有特定的函数，以及提取子字符串也有特定的函数。
4、判断两个字符串是否相等，不能通过"=="来判断，需要调用String类型中的equals()方法。
5、在写第三次作业时，由于输入格式的问题，就导致大部分人写不出来，经过这次作业后我知道可以通过正则表达式来验证用户的输入。写出相关的正则表达式后，可以用String类型中的matches()方法来匹配符合正则表达式的一个字符串集。
6、在做比较复杂的题目时，首先一定要建好相关的类，类建的好整体结构就相当的清晰，做题时可以省去不少的麻烦。
四、改进建议
我认为我的代码最大的改进就是要建立好相关的类，同时还要理清类与类之间的关系。一些重复出现的代码，需要写一个方法，减少代码的不良性，为代码添加可扩展性。像我写的代码有很多地方，有很多代码的逻辑一样，有很明显的代码复制现象，因此写好方法也是我需要去改进的地方。还有要弄清楚类与方法的关系，不能将与类无关的方法放进这个类中。就如我第一次用类来写题，类没有建立好，方法在类中也是乱的，所以建立的类也没有了任何意义，看上去都是方法。因此我需要在建立类上作出改进，找出代码重复的地方并写好方法。
五、总结
通过这三次作业，每次作业都有不同的体会。第一次作业虽然简单，但是还有不少地方出错了。原因在于考虑问题不全面，以及输出格式的错误。所以接下来我需要重视细节，考虑周全。第二次作业我学到了String类型中的相关方法，例如substring()和equals()方法，都能够很好的解决字符串相关的问题。收获最多的还是在第三次作业，首先我了解了正则表达式可以很好的处理用户输入的格式，给我们去判断用户输入不同内容带来了极大的便利。其次我学会了如何去创建类以及写好类，类创建好了代码的整体框架就非常清晰了，类中的方法也需要写全，并能够解决相应的问题。这三次作业也让我有了进一步提高，接下来还需要更加的努力，去提高自己的编程能力。
浙公网安备 33010602011771号