PTA第4、5次大作业及期中考试总结

PTA第4、5次大作业及期中考试总结

  1. 期中考试题目总结
    (1)总结:期中考试主要考察的是点线面类的设计,之前没有接触过类,或者说对类没有什么很清晰的概念和认知。现在才发现“类”是一个非常强大的工具,可以大大方便我们平时解决问题的过程。期中考试这几道题目难度适中,很适合我们平时拿来练手,不过也需要抓住各种细节,以防出现一些不该出现的错误。
    (2)
    1、7-1 点与线(类设计)

设计一个类表示平面直角坐标系上的点Point,私有属性分别为横坐标x与纵坐标y,数据类型均为实型数,除构造方法以及属性的getter与setter方法外,定义一个用于显示信息的方法display(),用来输出该坐标点的坐标信息,格式如下:(x,y),数值保留两位小数。为简化题目,其中,坐标点的取值范围设定为(0,200]。若输入有误,系统则直接输出Wrong Format

设计一个类表示平面直角坐标系上的线Line,私有属性除了标识线段两端的点point1、point2外,还有一个字符串类型的color,用于表示该线段的颜色,同样,除构造方法以及属性的getter与setter方法外,定义一个用于计算该线段长度的方法getDistance(),还有一个用于显示信息的方法display(),用来输出线段的相关信息,输出格式如下:

    The line"s color is:颜色值
    The line"s begin point"s Coordinate is:
    (x1,y1)
    The line"s end point"s Coordinate is:
    (x2,y2)
    The line"s length is:长度值

其中,所有数值均保留两位小数,建议可用String.format("%.2f", data)方法。

设计类图如下图所示。

** 题目要求:在主方法中定义一条线段对象,从键盘输入该线段的起点坐标与终点坐标以及颜色,然后调用该线段的display()方法进行输出。**

以下情况为无效作业
无法运行
设计不符合所给类图要求
未通过任何测试点测试
判定为抄袭
输入格式:
分别输入线段的起点横坐标、纵坐标、终点的横坐标、纵坐标以及颜色,中间可用一个或多个空格、tab或者回车分隔。

输出格式:
The line"s color is:颜色值
The line"s begin point"s Coordinate is:
(x1,y1)
The line"s end point"s Coordinate is:
(x2,y2)
The line"s length is:长度值
输入样例1:
在这里给出一组输入。例如:

5
9.4
12.3
84
Red
输出样例1:
在这里给出相应的输出。例如:

The line"s color is:Red
The line"s begin point"s Coordinate is:
(5.00,9.40)
The line"s end point"s Coordinate is:
(12.30,84.00)
The line"s length is:74.96
输入样例2:
在这里给出一组输入。例如:

80.2356
352.12
24.5
100
Black
输出样例2:
在这里给出相应的输出。例如:

Wrong Format

我的代码如下:

点击查看代码
package pta.mid_term_examination;

import java.text.DecimalFormat;
import java.util.Scanner;

public class Main1 {
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        Point point1=new Point();
        double x1=in.nextDouble();
        double y1=in.nextDouble();
        point1.setX(x1);
        point1.setY(y1);
        Point point2=new Point();
        double x2=in.nextDouble();
        double y2=in.nextDouble();
        point2.setX(x2);
        point2.setY(y2);
        //double a=x1*x1-x2*x2;
        //double b=y1*y1-y2*y2;
        //double dis=Math.sqrt(a+b);
        String color=in.next();
        Line line=new Line();
        line.setPoint1(point1);
        line.setPoint2(point2);
        line.setColor(color);
        if ((x1<=0||x1>200)||(y1<=0||y1>200)||(x2<=0||x2>200)||(y2<=0||y2>200))
            System.out.println("Wrong Format");
        else line.display();
    }
}

class Point{
    private double x;//横坐标
    private double y;//纵坐标

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public Point() {
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public void display(){
        DecimalFormat two=new DecimalFormat("0.00");
        System.out.println("("+two.format(getX())+","+two.format(getY())+")");
    }
}

class Line{
    private Point point1 = new Point();
    private Point point2 = new Point();
    String color;

    public Line(Point point1, Point point2, String color) {
        this.point1 = point1;
        this.point2 = point2;
        this.color = color;
    }

    public Line() {
    }

    public Point getPoint1() {
        return point1;
    }

    public void setPoint1(Point point1) {
        this.point1 = point1;
    }

    public Point getPoint2() {
        return point2;
    }

    public void setPoint2(Point point2) {
        this.point2 = point2;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getDistance(Point p1,Point p2){

        double a=p1.getX()-p2.getX();
        double b=p1.getY()-p2.getY();

        return Math.sqrt(a*a+b*b);
    }
    public void display(){
        Line line=new Line();
        DecimalFormat two=new DecimalFormat("0.00");
        System.out.println("The line"s color is:"+getColor());
        System.out.println("The line"s begin point"s Coordinate is:");
        point1.display();
        System.out.println("The line"s end point"s Coordinate is:");
        point2.display();
        System.out.println("The line"s length is:" + two.format(line.getDistance(point1,point2)));
    }
}

本题把我困扰住的地方是Line类里面的getDistance方法
public double getDistance(Point p1,Point p2){

    double a=p1.getX()-p2.getX();
    double b=p1.getY()-p2.getY();

    return Math.sqrt(a*a+b*b);
}

这里一开始我并没有添加函数括号里面的参数,导致后面运行的时候一直显示的不是正确的答案,而是一直显示0.00。
在括号中加上参数并在其它地方做出一些修改,最后的问题才得以解决。
在这里我知道了仔细观察题目和平时基础的重要性,这大大影响了我做题时候的思考方式和速度。

2、7-2 点线面问题重构(继承与多态)
在“点与线(类设计)”题目基础上,对题目的类设计进行重构,以实现继承与多态的技术性需求。

对题目中的点Point类和线Line类进行进一步抽象,定义一个两个类的共同父类Element(抽象类),将display()方法在该方法中进行声明(抽象方法),将Point类和Line类作为该类的子类。
再定义一个Element类的子类面Plane,该类只有一个私有属性颜色color,除了构造方法和属性的getter、setter方法外,display()方法用于输出面的颜色,输出格式如下:The Plane"s color is:颜色
在主方法内,定义两个Point(线段的起点和终点)对象、一个Line对象和一个Plane对象,依次从键盘输入两个Point对象的起点、终点坐标和颜色值(Line对象和Plane对象颜色相同),然后定义一个Element类的引用,分别使用该引用调用以上四个对象的display()方法,从而实现多态特性。示例代码如下:
element = p1;//起点Point
element.display();

  element = p2;//终点Point
  element.display();
  
  element = line;//线段
  element.display();
  
  element = plane;//面
  element.display();

类结构如下图所示。

其中,所有数值均保留两位小数,建议可用String.format("%.2f", data)方法。

以下情况为无效作业
无法运行
设计不符合所给类图要求
未通过任何测试点测试
判定为抄袭
输入格式:
分别输入线段的起点横坐标、纵坐标、终点的横坐标、纵坐标以及颜色,中间可用一个或多个空格、tab或者回车分隔。

输出格式:
(x1,y1)
(x2,y2)
The line"s color is:颜色值
The line"s begin point"s Coordinate is:
(x1,y1)
The line"s end point"s Coordinate is:
(x2,y2)
The line"s length is:长度值
The Plane"s color is:颜色值
输入样例1:
在这里给出一组输入。例如:

5
9.4
12.3
84
Red
输出样例1:
在这里给出相应的输出。例如:

(5.00,9.40)
(12.30,84.00)
The line"s color is:Red
The line"s begin point"s Coordinate is:
(5.00,9.40)
The line"s end point"s Coordinate is:
(12.30,84.00)
The line"s length is:74.96
The Plane"s color is:Red
输入样例2:
在这里给出一组输入。例如:

5
9.4
12.3
845
Black
输出样例2:
在这里给出相应的输出。例如:

Wrong Format

以下是我的代码:

点击查看代码
package pta.mid_term_examination;

import java.text.DecimalFormat;
import java.util.Scanner;

public class Main2 {
    public static void main(String[] args){
        Scanner in=new Scanner(System.in);
        Point1 p1=new Point1();
        double x1=in.nextDouble();
        double y1=in.nextDouble();
        p1.setX(x1);
        p1.setY(y1);
        Point1 p2=new Point1();
        double x2=in.nextDouble();
        double y2=in.nextDouble();
        p2.setX(x2);
        p2.setY(y2);
        String color=in.next();
        Line1 line=new Line1();
        line.setPoint1(p1);
        line.setPoint2(p2);
        line.setColor(color);
        Plane plane=new Plane();
        plane.setColor(color);
        Element element=new Element() {
            @Override
            public void display() {

            }
        };
        if ((x1<=0||x1>200)||(y1<=0||y1>200)||(x2<=0||x2>200)||(y2<=0||y2>200))
            System.out.println("Wrong Format");
        else{
            element = p1;//起点Point
            element.display();

            element = p2;//终点Point
            element.display();

            element = line;//线段
            element.display();

            element = plane;//面
            element.display();
        }
    }
}

abstract class Element{
    public abstract void display();
}

class Point1 extends Element{
    private double x;//横坐标
    private double y;//纵坐标

    public Point1(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public Point1() {
    }

    public double getX() {
        return x;
    }

    public void setX(double x) {
        this.x = x;
    }

    public double getY() {
        return y;
    }

    public void setY(double y) {
        this.y = y;
    }

    public void display(){
        DecimalFormat two=new DecimalFormat("0.00");
        System.out.println("("+two.format(this.x)+","+two.format(this.y)+")");
    }
}

class Line1 extends Element{
    private Point1 point1 = new Point1();
    private Point1 point2 = new Point1();
    String color;

    public Line1(Point1 point1, Point1 point2, String color) {
        this.point1 = point1;
        this.point2 = point2;
        this.color = color;
    }

    public Line1() {
    }

    public Point1 getPoint1() {
        return point1;
    }

    public void setPoint1(Point1 point1) {
        this.point1 = point1;
    }

    public Point1 getPoint2() {
        return point2;
    }

    public void setPoint2(Point1 point2) {
        this.point2 = point2;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public double getDistance(Point1 p1,Point1 p2){

        double a=p1.getX()-p2.getX();
        double b=p1.getY()-p2.getY();

        return Math.sqrt(a*a+b*b);
    }
    public void display(){
        Line1 line=new Line1();
        DecimalFormat two=new DecimalFormat("0.00");
        System.out.println("The line"s color is:"+getColor());
        System.out.println("The line"s begin point"s Coordinate is:");
        point1.display();
        System.out.println("The line"s end point"s Coordinate is:");
        point2.display();
        System.out.println("The line"s length is:" + two.format(line.getDistance(point1,point2)));
    }
}

class Plane extends Element{
    private String color;

    public Plane(String color) {
        this.color = color;
    }

    public Plane() {
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    public void display(){
        System.out.println("The Plane"s color is:"+this.color);
    }
}

第二次作业是在第一次作业的基础上加上了继承与多态的运用,继承和多态是我们Java学习中非常非常非常重要的两个知识点,它们有以下好处:
使用继承的好处是父类的内部细节对子类可见
使用多态可以使程序有良好的扩展,并可以对所有类的对象进行通用处理
使用继承和多态可以增强我们代码的灵活性,接口性,可扩充性,也可以消除类型之间的耦合关系。

第二次作业除了加上了继承和多态等操作,还定义了抽象类,这也是一个新的知识,抽象类加上抽象方法。咋一听很吓人,但是只要我们去仔细阅读题目要求,仔细审题,然后再看,就可以有更多的体会以及解题思路。

3、7-3 点线面问题再重构(容器类)
在“点与线(继承与多态)”题目基础上,对题目的类设计进行重构,增加容器类保存点、线、面对象,并对该容器进行相应增、删、遍历操作。

在原有类设计的基础上,增加一个GeometryObject容器类,其属性为ArrayList类型的对象(若不了解泛型,可以不使用
增加该类的add()方法及remove(int index)方法,其功能分别为向容器中增加对象及删除第index - 1(ArrayList中index>=0)个对象
在主方法中,用户循环输入要进行的操作(choice∈[0,4]),其含义如下:
1:向容器中增加Point对象
2:向容器中增加Line对象
3:向容器中增加Plane对象
4:删除容器中第index - 1个数据,若index数据非法,则无视此操作
0:输入结束
示例代码如下:
choice = input.nextInt();
while(choice != 0) {
switch(choice) {
case 1://insert Point object into list
...
break;
case 2://insert Line object into list
...
break;
case 3://insert Plane object into list
...
break;
case 4://delete index - 1 object from list
int index = input.nextInt();
...
}
choice = input.nextInt();
}
输入结束后,按容器中的对象顺序分别调用每个对象的display()方法进行输出。
类图如下所示:

以下情况为无效作业
无法运行
设计不符合所给类图要求
未通过任何测试点测试
判定为抄袭
输入格式:
switch(choice) {
case 1://insert Point object into list
输入“点”对象的x,y值
break;
case 2://insert Line object into list
输入“线”对象两个端点的x,y值
break;
case 3://insert Plane object into list
输入“面”对象的颜色值
break;
case 4://delete index - 1 object from list
输入要删除的对象位置(从1开始)
...
}
输出格式:
Point、Line、Plane的输出参考题目2
删除对象时,若输入的index超出合法范围,程序自动忽略该操作
输入样例:
在这里给出一组输入。例如:

1
3.4
5.6
2
4.4
8.0
0.98
23.888
Red
3
Black
1
9.8
7.5
3
Green
4
3
0
输出样例:
在这里给出相应的输出。例如:

(3.40,5.60)
The line"s color is:Red
The line"s begin point"s Coordinate is:
(4.40,8.00)
The line"s end point"s Coordinate is:
(0.98,23.89)
The line"s length is:16.25
(9.80,7.50)
The Plane"s color is:Green

题目代码如下:

点击查看代码
package pta.mid_term_examination;

import java.util.ArrayList;
import java.util.Scanner;

abstract class Element3 {
	public abstract void display();

}

class Plane3 extends Element3 {
	private String color;	

	public Plane3() {
		super();
		// TODO Auto-generated constructor stub
	}

	public Plane3(String color) {
		super();
		this.color = color;
	}
	

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	@Override
	public void display() {
		// TODO Auto-generated method stub
		System.out.println("The Plane"s color is:" + this.color);

	}

}

class Point3 extends Element3{
	private double x,y;
	
	public Point3(){
		
	}
	
	public Point3(double x,double y){
		this.x = x;
		this.y = y;
	}
	
	public double getX(){
		return this.x;
	}
	
	public void setX(double x){
		this.x = x;		
	}
	
	public double getY(){
		return this.y;
	}
	
	public void setY(double y){
		this.y = y;
	}
	
	@Override
	public void display(){
		System.out.println("(" + String.format("%.2f", x) + "," + String.format("%.2f",y) + ")");
	}

}

class Line3 extends Element3{
	private Point3 point1,point2;
	private String color;
	
	public Line3(){
		
	}
	
	public Line3(Point3 p1,Point3 p2,String color){
		this.point1 = p1;
		this.point2 = p2;
		this.color =  color;
	}

	public Point3 getPoint1() {
		return point1;
	}

	public void setPoint1(Point3 point1) {
		this.point1 = point1;
	}

	public Point3 getPoint2() {
		return point2;
	}

	public void setPoint2(Point3 point2) {
		this.point2 = point2;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}
	
	public double getDistance(){
		return Math.sqrt(Math.pow(this.point1.getX() - this.point2.getX(), 2) +
				Math.pow(this.getPoint1().getY() - this.getPoint2().getY(), 2));
	}
	
	@Override
	public void display(){
		System.out.println("The line"s color is:" + this.getColor());
		System.out.println("The line"s begin point"s Coordinate is:"); 
		this.getPoint1().display();
		System.out.println("The line"s end point"s Coordinate is:"); 
		this.getPoint2().display();
		System.out.println("The line"s length is:" + String.format("%.2f", this.getDistance()));
	}

}

class GeometryObject{
	private ArrayList<Element3> list = new ArrayList<>();
	
	public GeometryObject() {
		
	}
	
	public void add(Element3 element) {
		list.add(element);
	}
	
	public void remove(int index) {
		if(index < 1 || index > list.size()) {
			return;
		}
		
		list.remove(index - 1);
	}	
	
	public ArrayList<Element3> getList(){
		return this.list;
	}
}

public class Main3 {

	public static void main(String[] args) {
		double x1,y1,x2,y2;
		String color;
		Scanner input = new Scanner(System.in);
		int choice = 0,index = 0;
		
		GeometryObject container = new GeometryObject();		
		
		choice = input.nextInt();
		while(choice != 0) {
			switch(choice) {
			case 1:
				x1 = input.nextDouble();
				y1 = input.nextDouble();
				container.add(new Point3(x1,y1));
				break;
			case 2:
				x1 = input.nextDouble();
				y1 = input.nextDouble();
				x2 = input.nextDouble();
				y2 = input.nextDouble();
				color = input.next();
				container.add(new Line3(new Point3(x1,y1),new Point3(x2,y2),color));
				break;
			case 3:
				color = input.next();
				container.add(new Plane3(color));
				break;
			case 4:
				index = input.nextInt();
				container.remove(index);
				break;
			}
			choice = input.nextInt();
		}
		
		for(Element3 element:container.getList()) {
			element.display();
		}
	}

}

第三题是本次期中考试难度最大的一题,因为加上了容器类和泛型的应用,从上面的类图我们也可以发现类图也是明显比前两题要复杂很多。
所以当时考试的时候由于时间问题,这题我并没有解决,后面看了老师发的源码才有了些许体会。

  1. PTA第4次大作业总结
    1、7-1 sdut-String-2 识蛟龙号载人深潜,立科技报国志(II)(正则表达式)
    背景简介:

“蛟龙号”载人深潜器是我国首台自主设计、自主集成研制的作业型深海载人潜水器,设计最大下潜深度为7000米级,也是目前世界上下潜能力最强的作业型载人潜水器。“蛟龙号”可在占世界海洋面积99.8%的广阔海域中使用,对于我国开发利用深海的资源有着重要的意义。

中国是继美、法、俄、日之后世界上第五个掌握大深度载人深潜技术的国家。在全球载人潜水器中,“蛟龙号”属于第一梯队。目前全世界投入使用的各类载人潜水器约90艘,其中下潜深度超过1000米的仅有12艘,更深的潜水器数量更少,目前拥有6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯。除中国外,其他4国的作业型载人潜水器最大工作深度为日本深潜器的6527米,因此“蛟龙号”载人潜水器在西太平洋的马里亚纳海沟海试成功到达7020米海底,创造了作业类载人潜水器新的世界纪录。

从2009年至2012年,蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功。下潜至7000米,说明蛟龙号载人潜水器集成技术的成熟,标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一。

2012年6月27日11时47分,中国“蛟龙”再次刷新“中国深度”——下潜7062米。6月3日,“蛟龙”出征以来,已经连续书写了5个“中国深度”新纪录:6月15日,6671米;6月19日,6965米;6月22日,6963米;6月24日,7020米;6月27日,7062米。下潜至7000米,标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力,标志着“蛟龙”载人潜水器集成技术的成熟,标志着我国深海潜水器成为海洋科学考察的前沿与制高点之一,标志着中国海底载人科学研究和资源勘探能力达到国际领先水平。

‘蛟龙’号是我国载人深潜发展历程中的一个重要里程碑。它不只是一个深海装备,更代表了一种精神,一种不畏艰险、赶超世界的精神,它是中华民族进军深海的号角。

了解蛟龙号”载人深潜器“的骄人业绩,为我国海底载人科学研究和资源勘探能力达到国际领先水平而自豪,小伙伴们与祖国同呼吸、共命运,一定要学好科学文化知识、提高个人能力,增强创新意识,做事精益求精,立科技报国之志!

请编写程序,实现如下功能:读入关于蛟龙号载人潜水器探测数据的多行字符串,从给定的信息找出数字字符,输出每行的数字之和。

提示 若输入为“2012年2月”,则该行的输出为:2014。若干个连续的数字字符作为一个整体,以十进制形式相加。

输入格式:
读入关于蛟龙号载人潜水器探测数据的多行字符串,每行字符不超过80个字符。

以"end"结束。

输出格式:
与输入行相对应的各个整数之和。

输入样例1:
2012年6月27日11时47分,中国“蛟龙”再次刷新“中国深度”——下潜7062米
6月15日,6671米
6月19日,6965米
6月22日,6963米
6月24日,7020米
6月27日,7062米
下潜至7000米,标志着我国具备了载人到达全球99%以上海洋深处进行作业的能力
end
输出样例1:
9165
6692
6990
6991
7050
7095
7099
输入样例2:
全世界投入使用的各类载人潜水器约90艘,下潜深度超过1000米的仅有12艘,更深的潜水器数量更少
6000米以上深度载人潜水器的国家包括中国、美国、日本、法国和俄罗斯
日本深潜器下潜6527米,蛟龙号在马里亚纳海沟海试成功到达7020米海底,创造了新的世界纪录
从2009年至2012年,蛟龙号接连取得1000米级、3000米级、5000米级和7000米级海试成功
下潜至7000米,说明蛟龙号载人潜水器集成技术的成熟
end
输出样例2:
1102
6000
13547
20021
7000

代码如下:

点击查看代码
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        while (true){
            String str = in.nextLine();
            String[] s = str.split("\D+");
            // \d表示数字  \D表示所有非数字字符,加上+号表示一个或多个
            int sum = 0;//用于计算总和
            int count = 0;//用于统计每一行被强制转化的字符串
            if (str.equals("end"))
                break;
            for (int i = 0;i < s.length;i++){
                if (!s[i].equals("")){
                    count = Integer.parseInt(s[i]);
                    sum += count;
                }

            }
            System.out.println(sum);
        }
    }
}

踩坑心得:Java spilt方法的使用和next()与nextLine()的区别
String[] s = str.split("D+");
// d表示数字 D表示所有非数字字符,加上+号表示一个或多个
nextLine()方法返回的是Enter键之前的所有字符,它是可以得到带空格的字符串的。

next()会自动消去有效字符前的空格,只返回输入的字符,不能得到带空格的字符串。

(简单点说,next我只要字,nextLine我啥都要)

2、7-2 点线形系列4-凸四边形的计算
用户输入一组选项和数据,进行与四边形有关的计算。
以下四边形顶点的坐标要求按顺序依次输入,连续输入的两个顶点是相邻顶点,第一个和最后一个输入的顶点相邻。
选项包括:
1:输入四个点坐标,判断是否是四边形、平行四边形,判断结果输出true/false,结果之间以一个英文空格符分隔。
2:输入四个点坐标,判断是否是菱形、矩形、正方形,判断结果输出true/false,结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形,输出"not a quadrilateral"
3:输入四个点坐标,判断是凹四边形(false)还是凸四边形(true),输出四边形周长、面积,结果之间以一个英文空格符分隔。 若四个点坐标无法构成四边形,输出"not a quadrilateral"
4:输入六个点坐标,前两个点构成一条直线,后四个点构成一个四边形或三角形,输出直线与四边形(也可能是三角形)相交的交点数量。如果交点有两个,再按面积从小到大输出四边形(或三角形)被直线分割成两部分的面积(不换行)。若直线与四边形或三角形的一条边线重合,输出"The line is coincide with one of the lines"。若后四个点不符合四边形或三角形的输入,输出"not a quadrilateral or triangle"。
后四个点构成三角形的情况:假设三角形一条边上两个端点分别是x、y,边线中间有一点z,另一顶点s:
1)符合要求的输入:顶点重复或者z与xy都相邻,如x x y s、x z y s、x y x s、s x y y。此时去除冗余点,保留一个x、一个y。
2) 不符合要求的输入:z 不与xy都相邻,如z x y s、x z s y、x s z y
5:输入五个点坐标,输出第一个是否在后四个点所构成的四边形(限定为凸四边形,不考虑凹四边形)或三角形(判定方法见选项4)的内部(若是四边形输出in the quadrilateral/outof the quadrilateral,若是三角形输出in the triangle/outof the triangle)。如果点在多边形的某条边上,输出"on the triangle或者on the quadrilateral"。若后四个点不符合四边形或三角形,输出"not a quadrilateral or triangle"。

输入格式:
基本格式:选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔,点与点之间以一个英文空格分隔。

输出格式:
基本输出格式见每种选项的描述。
异常情况输出:
如果不符合基本格式,输出"Wrong Format"。
如果符合基本格式,但输入点的数量不符合要求,输出"wrong number of points"。
注意:输出的数据若小数点后超过3位,只保留小数点后3位,多余部分采用四舍五入规则进到最低位。小数点后若不足3位,按原始位数显示,不必补齐。例如:1/3的结果按格式输出为 0.333,1.0按格式输出为1.0

选项1、2、3中,若四边形四个点中有重合点,输出"points coincide"。
选项4中,若前两个输入线的点重合,输出"points coincide"。

输入样例1:
选项1,点重合。例如:

1:-1,-1 -1,-1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如:

points coincide
输入样例2:
不符合基本格式。例如:

1:-1,-1 1,2 -1,1 ++1,0
输出样例:
在这里给出相应的输出。例如:

Wrong Format
输入样例3:
选项1,输入点数量不对。例如:

1:-1,-1 -1,2
输出样例:
在这里给出相应的输出。例如:

wrong number of points
输入样例4:
选项1,正确输入判断。例如:

1:-1,-1 -1,1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如:

true false
输入样例5:
选项2,输入点不构成四边形。例如:

2:10,10 1,1 0,0 1,20
输出样例:
在这里给出相应的输出。例如:

not a quadrilateral
输入样例6:
选项2,正方形。例如:

2:0,0 0,80 80,80 80,0
输出样例:
在这里给出相应的输出。例如:

true true true
输入样例7:
选项2。例如:

2:0,0 -10,80 0,160 -10,80
输出样例:
在这里给出相应的输出。例如:

not a quadrilateral
输入样例8:
选项3,凸四边形。例如:

3:-1,-1 -1,1 1,2 1,-2
输出样例:
在这里给出相应的输出。例如:

true 10.472 6.0
输入样例9:
选项3,。例如:

3:0,0 -10,100 0,99 10,100
输出样例:
在这里给出相应的输出。例如:

false 221.097 990.0

我的代码:

点击查看代码
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        boolean flag = true;
        String regStr = "[\-\+]?\d+(\.\d+)?,[\-\+]?\d+(\.\d+)?(\s[\-\+]?\d+(\.\d+)?,[\-\+]?\d+(\.\d+)?\s?){0,}";
        if (str.length() > 2){
            String str1 = str.substring(0,1);
            String str2 = str.substring(2,str.length());
            if (str2.matches(regStr))
                flag = true;
            else flag = false;
            if (!flag) {
                System.out.println("Wrong Format");
                return;
            }else {
                String[] s = str2.split(",|\s");
                for (int i = 0;i < s.length;i++){
                    if (s[i].matches("0\d+"))
                        System.out.println("Wrong Format");
                }
                Quadrilateral qua = new Quadrilateral(Double.parseDouble(s[0]),Double.parseDouble(s[1]),Double.parseDouble(s[2]),Double.parseDouble(s[3]),Double.parseDouble(s[4]),Double.parseDouble(s[5]),Double.parseDouble(s[6]),Double.parseDouble(s[7]));
                if (qua.isCoincide()){
                    System.out.println("points coincide");
                    return;
                }else System.out.println(qua.isQuadrilateral()+" "+qua.isParallelogram());
                if (!qua.isQuadrilateral())
                    System.out.println("not a quadrilateral");
                else System.out.println(qua.isDiamond()+" "+qua.isRectangle()+" "+qua.isSquare());
               
            }
        }
    }
}

class Quadrilateral{
    //定义四边形类
    private double x1,y1,x2,y2,x3,y3,x4,y4;

    public Quadrilateral(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
        this.x3 = x3;
        this.y3 = y3;
        this.x4 = x4;
        this.y4 = y4;
    }

    public Quadrilateral() {
        super();
    }

    public double getX1() {
        return x1;
    }

    public void setX1(double x1) {
        this.x1 = x1;
    }

    public double getY1() {
        return y1;
    }

    public void setY1(double y1) {
        this.y1 = y1;
    }

    public double getX2() {
        return x2;
    }

    public void setX2(double x2) {
        this.x2 = x2;
    }

    public double getY2() {
        return y2;
    }

    public void setY2(double y2) {
        this.y2 = y2;
    }

    public double getX3() {
        return x3;
    }

    public void setX3(double x3) {
        this.x3 = x3;
    }

    public double getY3() {
        return y3;
    }

    public void setY3(double y3) {
        this.y3 = y3;
    }

    public double getX4() {
        return x4;
    }

    public void setX4(double x4) {
        this.x4 = x4;
    }

    public double getY4() {
        return y4;
    }

    public void setY4(double y4) {
        this.y4 = y4;
    }

    public boolean isCoincide(){
        //判断四边形的点是否重合的函数
        if((x1==x2&&y1==y2)||(x2==x3&&y2==y3)||(x3==x4&&y3==y4)||(x4==x1&&y4==y1))
            return true;
        return false;
    }

    public boolean isQuadrilateral(){
        //判断是否为四边形
        Line a1 = new Line(x2,y2,x3,y3,x1,y1,x4,y4);
        Line a2 = new Line(x4,y4,x3,y3,x1,y1,x2,y2);
        if((x1==x3&&y1==y3)||(x2==x4&&y2==y4)||(x1==x2&&y1==y2)||(x4==x3&&y4==y3)||a1.three()||a2.three())
            return false;
        else if((x1==x2&&x1==x3)||(x1==x2&&x1==x4)||(x1==x3&&x1==x4)||(x3==x2&&x3==x4))
            return false;
        else if(Math.abs((y1-y2)/(x1-x2)-(y1-y3)/(x1-x3))<0.01||Math.abs((y1-y2)/(x1-x2)-(y1-y4)/(x1-x4))<0.01||Math.abs((y1-y4)/(x1-x4)-(y1-y3)/(x1-x3))<0.01||Math.abs((y3-y2)/(x3-x2)-(y2-y4)/(x2-x4))<0.01)
            return false;
        else return true;
    }

    public boolean isParallelogram() {
        //判断是否为平行四边形
        if(isQuadrilateral()) {
            if((x1==x2&&x3==x4||(y1-y2)/(x1-x2)==(y4-y3)/(x4-x3))&&(x3==x2&&x1==x4||(y3-y2)/(x3-x2)==(y4-y1)/(x4-x1)))
                return true;
            else return false;
        }
        else return false;
    }

    public boolean isDiamond() {
        //判断是否为菱形
        if(isParallelogram()) {
            if(((y1==y3&&x2==x4)||(y2==y4&&x1==x3))||(((y1-y3)/(x1-x3))*((y4-y2)/(x4-x2))==-1)) return true;
            else return false;
        }
        else return false;
    }

    public boolean isRectangle() {
        //判断是否为矩形
        if(isParallelogram()) {
            if((x1==x2&&y2==y3)||(y1==y2&&x2==x3)||((y1-y2)/(x1-x2))*((y3-y2)/(x3-x2))==-1) return true;
            else return false;
        }
        else return false;
    }

    public boolean isSquare() {
        //判断是否为正方形
        if(isRectangle()&&isDiamond()) return true;
        else return false;
    }
    public boolean isBump() {
        //判断是否为凸四边形
        double x = -((x2-x4)*(x3*y1-x1*y3)-(x1-x3)*(x4*y2-x2*y4))/((y2-y4)*(x1-x3)-(y1-y3)*(x2-x4));
        double y = -((y2-y4)*(y3*x1-y1*x3)-(y1-y3)*(y4*x2-y2*x4))/((x2-x4)*(y1-y3)-(x1-x3)*(y2-y4));
        if ((((x>=x3&&x<=x1)||(x<=x3&&x>=x1))&&((y>=y3&&y<=y1)||(y<=y3&&y>=y1)))&&(((x>=x2&&x<=x4)||(x<=x2&&x>=x4))&&((y>=y2&&y<=y4)||(y<=y2&&y>=y4))))
            return true;
        else return false;
    }
}

class Line{
    //定义直线类
    private double x1,y1,x2,y2,x3,y3,x4,y4;

    public Line() {
        super();
    }

    public Line(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) {
        super();
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
        this.x3 = x3;
        this.y3 = y3;
        this.x4 = x4;
        this.y4 = y4;
    }

    public double getX1() {
        return x1;
    }

    public void setX1(double x1) {
        this.x1 = x1;
    }

    public double getY1() {
        return y1;
    }

    public void setY1(double y1) {
        this.y1 = y1;
    }

    public double getX2() {
        return x2;
    }

    public void setX2(double x2) {
        this.x2 = x2;
    }

    public double getY2() {
        return y2;
    }

    public void setY2(double y2) {
        this.y2 = y2;
    }

    public double getX3() {
        return x3;
    }

    public void setX3(double x3) {
        this.x3 = x3;
    }

    public double getY3() {
        return y3;
    }

    public void setY3(double y3) {
        this.y3 = y3;
    }

    public double getX4() {
        return x4;
    }

    public void setX4(double x4) {
        this.x4 = x4;
    }

    public double getY4() {
        return y4;
    }

    public void setY4(double y4) {
        this.y4 = y4;
    }

    public boolean isCoincide(){
        if(Math.abs((y4-y3)*x1+(x3-x4)*y1+x4*y3-y4*x3)/Math.sqrt((y4-y3)*(y4-y3)+(x4-x3)*(x4-x3))<0.01&&(Math.abs((y1-y2)/(x1-x2)-(y3-y4)/(x3-x4))<0.01||((x1==x2)&&(x3==x4))))
            return true;
        else return false;
    }
    public boolean three(){
        //小数点后三位
        double x = -((x3-x4)*(x2*y1-x1*y2)-(x1-x2)*(x4*y3-x3*y4))/((y3-y4)*(x1-x2)-(y1-y2)*(x3-x4));
        double y = -((y3-y4)*(y2*x1-y1*x2)-(y1-y2)*(y4*x3-y3*x4))/((x3-x4)*(y1-y2)-(x1-x2)*(y3-y4));
        if(Math.abs((y1-y2)/(x1-x2)-(y3-y4)/(x3-x4))<0.01)
            return false;
        else if (((x>=x3&&x<=x4)||(x<=x3&&x>=x4))&&((y>=y3&&y<=y4)||(y<=y3&&y>=y4))&&((x>=x1&&x<=x2)||(x<=x1&&x>=x2))&&((y>=y1&&y<=y2)||(y<=y1&&y>=y2)))
            return true;
        else return false;
    }
}

需要注意的地方:小数点的位数以及错误的情况

3、7-3 设计一个银行业务类
编写一个银行业务类BankBusiness,具有以下属性和方法:
(1)公有、静态的属性:银行名称bankName,初始值为“中国银行”。
(2)私有属性:账户名name、密码password、账户余额balance。
(3)银行对用户到来的欢迎(welcome)动作(静态、公有方法),显示“中国银行欢迎您的到来!”,其中“中国银行”自动使用bankName的值。
(4)银行对用户离开的提醒(welcomeNext)动作(静态、公有方法),显示“请收好您的证件和物品,欢迎您下次光临!”
(5)带参数的构造方法,完成开户操作。需要账户名name、密码password信息,同时让账户余额为0。
(6)用户的存款(deposit)操作(公有方法,需要密码和交易额信息),密码不对时无法存款且提示“您的密码错误!”;密码正确、完成用户存款操作后,要提示用户的账户余额,例如“您的余额有1000.0元。”。
(7)用户的取款(withdraw)操作(公有方法,需要密码和交易额信息)。密码不对时无法取款且提示“您的密码错误!”;密码正确但余额不足时提示“您的余额不足!”;密码正确且余额充足时扣除交易额并提示用户的账户余额,例如“请取走钞票,您的余额还有500.0元。”。

编写一个测试类Main,在main方法中,先后执行以下操作:
(1)调用BankBusiness类的welcome()方法。
(2)接收键盘输入的用户名、密码信息作为参数,调用BankBusiness类带参数的构造方法,从而创建一个BankBusiness类的对象account。
(3)调用account的存款方法,输入正确的密码,存入若干元。密码及存款金额从键盘输入。
(4)调用account的取款方法,输入错误的密码,试图取款若干元。密码及取款金额从键盘输入。
(5)调用account的取款方法,输入正确的密码,试图取款若干元(取款金额大于余额)。密码及取款金额从键盘输入。
(6)调用account的取款方法,输入正确的密码,试图取款若干元(取款金额小于余额)。密码及取款金额从键盘输入。
(7)调用BankBusiness类的welcomeNext()方法。

输入格式:
输入开户需要的姓名、密码
输入正确密码、存款金额
输入错误密码、取款金额
输入正确密码、大于余额的取款金额
输入正确密码、小于余额的取款金额

输出格式:
中国银行(银行名称)欢迎您的到来!
您的余额有多少元。
您的密码错误!
您的余额不足!
请取走钞票,您的余额还有多少元。
请收好您的证件和物品,欢迎您下次光临!

输入样例:
在这里给出一组输入。请注意,输入与输出是交替的,具体顺序请看测试类中的说明。例如:

张三 123456
123456 1000
654321 2000
123456 2000
123456 500
输出样例:
在这里给出相应的输出。请注意,输入与输出是交替的,具体顺序请看测试类中的说明。例如:

中国银行欢迎您的到来!
您的余额有1000.0元。
您的密码错误!
您的余额不足!
请取走钞票,您的余额还有500.0元。
请收好您的证件和物品,欢迎您下次光临!

我的代码如下:

点击查看代码
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String name = in.next();//账户名
        int input = in.nextInt();//密码
        BankBusiness bank = new BankBusiness(name,input);
        int rightPassword = in.nextInt();//正确密码
        double save = in.nextDouble();//存款金额
        int wrongPassword = in.nextInt();//错误密码
        double withdrawal = in.nextDouble();//取款金额
        int right1 = in.nextInt();//取款金额大于余额时的正确密码
        double withdrawal1 = in.nextDouble();//取款金额(大于余额)
        int right2 = in.nextInt();//取款金额小于余额时的正确密码
        double withdrawal2 = in.nextDouble();//取款金额(小于余额)
        BankBusiness.welcome();//直接用类名调用静态方法
        bank.deposit(rightPassword,save);
        bank.withdraw(wrongPassword,withdrawal);
        bank.withdraw(right1,withdrawal1);
        bank.withdraw(right2,withdrawal2);
        BankBusiness.welcomeNext();
    }
}

class BankBusiness{
    //编写一个银行业务类
    public static String bankName = "中国银行";//银行名称
    private String name;//账户名
    private int password;//密码
    private double balance;//账户余额

    public BankBusiness(String name, int password) {
        super();
        this.name = name;
        this.password = password;
        balance =0;
    }
    public static void welcome(){
        System.out.println(bankName + "欢迎您的到来!");
    }

    public static void welcomeNext() {
        System.out.println("请收好您的证件和物品,欢迎您下次光临!");
    }

    public void deposit(int input,double save){
        //参数是用户输入的密码和存款
        if (input != password)
            System.out.println("您的密码错误!");
        else {
            balance = balance + save;
            System.out.println("您的余额有" + balance + "元。");
        }
    }

    public void withdraw(int input,double withdrawal){
        //参数是用户输入的密码和取款
        if (input != password)
            System.out.println("您的密码错误!");
        else{
            if (balance < withdrawal)
                System.out.println("您的余额不足!");
            else {
                balance = balance - withdrawal;
                System.out.println("请取走钞票,您的余额还有" + balance + "元。");
            }
        }
    }
}

本题比较简单,我们需要提高代码的效率。

3.PTA第5次大作业总结
1、7-1 点线形系列5-凸五边形的计算-1
用户输入一组选项和数据,进行与五边形有关的计算。
以下五边形顶点的坐标要求按顺序依次输入,连续输入的两个顶点是相邻顶点,第一个和最后一个输入的顶点相邻。
选项包括:
1:输入五个点坐标,判断是否是五边形,判断结果输出true/false。
2:输入五个点坐标,判断是凹五边形(false)还是凸五边形(true),如果是凸五边形,则再输出五边形周长、面积,结果之间以一个英文空格符分隔。 若五个点坐标无法构成五边形,输出"not a pentagon"
3:输入七个点坐标,前两个点构成一条直线,后五个点构成一个凸五边形、凸四边形或凸三角形,输出直线与五边形、四边形或三角形相交的交点数量。如果交点有两个,再按面积从小到大输出被直线分割成两部分的面积(不换行)。若直线与多边形形的一条边线重合,输出"The line is coincide with one of the lines"。若后五个点不符合五边形输入,若前两点重合,输出"points coincide"。

以上3选项中,若输入的点无法构成多边形,则输出"not a polygon"。输入的五个点坐标可能存在冗余,假设多边形一条边上两个端点分别是x、y,边线中间有一点z,另一顶点s:
1)符合要求的输入:顶点重复或者z与xy都相邻,如:x x y s、x z y s、x y x s、s x y y。此时去除冗余点,保留一个x、一个y。
2) 不符合要求的输入:z不与xy都相邻,如:z x y s、x z s y、x s z y

输入格式:
基本格式:选项+":"+坐标x+","+坐标y+" "+坐标x+","+坐标y。点的x、y坐标之间以英文","分隔,点与点之间以一个英文空格分隔。

输出格式:
基本输出格式见每种选项的描述。
异常情况输出:
如果不符合基本格式,输出"Wrong Format"。
如果符合基本格式,但输入点的数量不符合要求,输出"wrong number of points"。
注意:输出的数据若小数点后超过3位,只保留小数点后3位,多余部分采用四舍五入规则进到最低位。小数点后若不足3位,按原始位数显示,不必补齐。例如:1/3的结果按格式输出为 0.333,1.0按格式输出为1.0

输入样例1:
选项1,点重合。例如:

1:-1,-1 1,2 -1,1 1,0
输出样例:
在这里给出相应的输出。例如:

wrong number of points

点击查看代码
import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        String[] s = str.split(" ");//将字符串按照空格分开,便于后面判断格式合法的坐标点数量
        boolean flag = true;
        String regStr = "([\+\-]?([0]|[1-9]+))(\.\d+)?\,([\+\-]?([0]|[1-9]+))(\.\d+)?(\s([\+\-]?([0]|[1-9]+))(\.\d+)?\,([+\-]?([0]|[1-9]+))(\.\d+)?)+";
        if (str.matches(regStr))
            flag = true;
        else flag = false;
        if (!flag){
            System.out.println("Wrong Format");
            return;
        }else {
            if (s.length != 2)
                System.out.println("wrong number of points");
            else {
                String[] s1 = s[0].split(",");
                String[] s2 = s[1].split(",");
                double x1 = Double.parseDouble(s1[0]);
                double y1 = Double.parseDouble(s1[1]);
                double x2 = Double.parseDouble(s2[0]);
                double y2 = Double.parseDouble(s2[1]);
                //double x1 = Double.parseDouble(String.valueOf(str.charAt(0)));//取出字符串第一个字符强制转化为double
                //double y1 = str.charAt(2);
                //double x2 = str.charAt(5);
                //double y2 = str.charAt(7);
                double a = x1 - x2;
                double b = y1 - y2;
                //System.out.println(x1);
                System.out.println(Math.sqrt(a*a+b*b));
            }
        }
    }
}

本次作业难度很大,超出了我的能力范围。

原文地址:https://www.cnblogs.com/zsl-236236/archive/2022/05/16/16276465.html