Pta纠错

题目：先从键盘输入一个整数n，之后回车再从键盘输入n个整数，整数之间用一个或多个空格分隔

要求：按如下示例输出排序后的数据：The sorted numbers are:排序后的n个数，每个输出的整数之后有一个空格作为分隔符

代码：

import java.util.Scanner;
import java.util.Arrays;

public class Main {
public static void main(String[] args)
{

Scanner inpute=new Scanner(System.in);

int n=inpute.nextInt();
int [] arry=new int [n];
for(int i=0;i<n;i++)
{
int temp=inpute.nextInt();
arry[i]=temp;
}
java.util.Arrays.parallelSort(arry);
for(int i=0;i<n;i++)
{
if(i==0)
System.out.print("The sorted numbers are:"+arry[i]+" ");
else
System.out.print(arry[i]+" ");
}
}
}

个人思考：一开始选择的排序方式是冒泡排序，觉得效率有些低下，后来学习到java内部类中有自带的快速排序方式

题目：输入三角形三条边，判断该三角形为什么类型的三角形。

输入格式：在一行中输入三角形的三条边的值（实型数），可以用一个或多个空格或回车分隔，其中三条边的取值范围均为[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”。

代码：

import java.util.Scanner;
public class Main {
public static void main(String[]args) {
Scanner inpute=new Scanner(System.in);
double a[]= new double [3];
for(int i=0;i<3;i++)
a[i]=inpute.nextDouble();
sort(a,0,2);

if((a[0]<1||a[0]>200)||(a[2]<1||a[2]>200)||(a[1]<1||a[1]>200))
System.out.println("Wrong Format");
else if(a[0]+a[1]<=a[2])
System.out.println("Not a triangle");
else if(a[0]==a[1]||a[1]==a[2])
System.out.println("Isosceles triangle");

else if((Math.pow(a[0],2)+Math.pow(a[1],2)==Math.pow(a[2],2))&&a[0]==a[1])
System.out.println("Isosceles right-angled triangle");
else if(Math.pow(a[0],2)+Math.pow(a[1],2)==Math.pow(a[2],2))
System.out.println("Right-angled triangle");
else if(a[0]==a[1]&&a[1]==a[2])
System.out.println("Equilateral triangle");
else
System.out.println("General triangle");
}
public static void sort(double[] arr,double begin,double end) {
//先定义两个参数接收排序起始值和结束值
double a = begin;
double b = end;
//先判断a是否大于b

if (a >= b) {
//没必要排序
return;
}
//基准数,默认设置为第一个值
double x = arr[(int) a];

//循环
while (a < b) {
//从后往前找,找到一个比基准数x小的值,赋给arr[a]
//如果a和b的逻辑正确--a<b ,并且最后一个值arr[b]>x,就一直往下找,直到找到后面的值大于x
while (a < b && arr[(int) b] >= x) {
b--;
}
//跳出循环,两种情况,一是a和b的逻辑不对了,a>=b,这时候排序结束.二是在后面找到了比x小的值
if (a < b) {
//将这时候找到的arr[b]放到最前面arr[a]
arr[(int) a] = arr[(int) b];
//排序的起始位置后移一位
a++;
}

//从前往后找,找到一个比基准数x大的值,放在最后面arr[b]
while (a < b && arr[(int) a] <= x) {
a++;
}
if (a < b) {
arr[(int) b] = arr[(int) a];
//排序的终止位置前移一位
b--;
}
}
//跳出循环 a < b的逻辑不成立了,a==b重合了,此时将x赋值回去arr[a]
arr[(int) a] = x;
//调用递归函数,再细分再排序
sort(arr,begin,a-1);
sort(arr,a+1,end);
}
}

个人思考：这道题没有全部写对，因为少考虑了一种情况，不过这一题我选择了自己写一个快速排序的方法，使自己对快速排序有了更深的理解

题目：

输入年月日的值（均为整型数），输出该日期的下一天。其中：年份的合法取值范围为[1820,2020] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。注意：不允许使用Java中和日期相关的类和方法。

要求：Main类中必须含有如下方法，签名如下：

public static void main(String[] args)；//主方法 
public static boolean isLeapYear(int year) ;//判断year是否为闰年，返回boolean类型 
public static boolean checkInputValidity(int year,int month,int day);//判断输入日期是否合法，返回布尔值
public static void nextDate(int year,int month,int day) ; //求输入日期的下一天
输入格式：在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。
输出格式：

当输入数据非法及输入日期不存在时，输出“Wrong Format”；
当输入日期合法，输出下一天，格式如下：Next date is:年-月-日

代码：

import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner inpute=new Scanner(System.in);
int year=inpute.nextInt();
int mounth=inpute.nextInt();
int day=inpute.nextInt();
boolean c=checkInputValidity(year,mounth,day);
if(!c)
System.out.println("Wrong Format");
else
nextDate(year,mounth,day);
}
public static boolean isLeapYear(int year) {
if(year%4==0&&year%100!=0||year%400==0)
return true;
else
return false;
}
public static boolean checkInputValidity(int year,int month,int day) {
if(month>12||month<1||year>2020||year<1820||(panduan(year,month)<day)||day<1||day>31)
return false;
else
return true;
}
public static void nextDate(int year,int month,int day) {
int sday=day+1;
if(panduan(year,month)<sday) {
month+=1;
if(month>12) {
year+=1;
month=1;
}
System.out.println("Next date is:"+year+"-"+month+"-1");
}
else
System.out.println("Next date is:"+year+"-"+month+"-"+sday);

}
public static int panduan(int year,int month) {
int [] arry= {31,28,31,30,31,30,31,31,30,31,30,31};
int [] arry1= {31,29,31,30,31,30,31,31,30,31,30,31};
if(isLeapYear(year)) {
return arry1[month-1];
}
else
return arry[month-1];
}
}

个人思考：这道题比较简单，只需要正确运用数组就能顺利解决

题目：输入年月日的值（均为整型数），同时输入一个取值范围在[-10,10] 之间的整型数n，输出该日期的前n天（当n > 0时）、该日期的后n天（当n<0时）。
其中年份取值范围为 [1820,2020] ,月份取值范围为[1,12] ,日期取值范围为[1,31] 。
注意：不允许使用Java中任何与日期有关的类或方法。
输入格式：在一行中输入年月日的值以及n的值，可以用一个或多个空格或回车分隔。
输出格式：

当输入的年、月、日以及n的值非法时，输出“Wrong Format”；
当输入数据合法时，输出“n days ago is:年-月-日”

代码：

import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner inpute=new Scanner(System.in);
int year=inpute.nextInt();
int mounth=inpute.nextInt();
int day=inpute.nextInt();
int n=inpute.nextInt();
if(mounth>12||mounth<1||year>2020||year<1820||day>31||day<1||jisuan(year,mounth)<day)
{
System.out.println("Wrong Format");
return;
}

if(n>0) {
int sday=day-n;
if(sday<0) {
if(mounth==1) {
System.out.println(n+" days ago is:"+(year-1)+"-"+12+"-"+(31+sday));
}
else {
System.out.println(n+" days ago is:"+year+"-"+(mounth-1)+"-"+(jisuan(year,(mounth-1))+sday));
}
}
else {
System.out.println(n+" days ago is:"+year+"-"+mounth+"-"+sday);
}
}
else {
int sday=Math.abs(n)+day;
if(sday>jisuan(year,mounth)) {
if(mounth==12) {
System.out.println(n+" days ago is:"+(year+1)+"-"+1+"-"+(sday-jisuan(year,mounth)));
}
else {
System.out.println(n+" days ago is:"+year+"-"+(mounth+1)+"-"+(sday-jisuan(year,mounth)));
}
}
else {
System.out.println(n+" days ago is:"+year+"-"+mounth+"-"+sday);
}

}

}
public static int jisuan(int year ,int month) {
int [] arry = {31,29,31,30,31,30,31,31,30,31,30,31};
int [] arry1 = {31,28,31,30,31,30,31,31,30,31,30,31};
if(isLeapYear(year))
return arry[month-1];
else return arry1[month-1];
}
public static boolean isLeapYear(int year) {
if(year%4==0&&year%100!=0||year%400==0)
return true;
else
return false;
}
}个人思考：这题与上题类似

题目：

定义一个类Date，包含三个私有属性年（year）、月（month）、日（day），均为整型数，其中：年份的合法取值范围为[1900,2000] ，月份合法取值范围为[1,12] ,日期合法取值范围为[1,31] 。注意：不允许使用Java中和日期相关的类和方法，否则按0分处理。

要求：Date类结构如下图所示：

输入格式：在一行内输入年月日的值，均为整型数，可以用一到多个空格或回车分隔。
输出格式：

当输入数据非法及输入日期不存在时，输出“Date Format is Wrong”；
当输入日期合法，输出下一天，格式如下：Next day is:年-月-日
代码：
import java.util.Scanner;

public class Main {
public static void main(String[] args) {
Scanner inpute=new Scanner(System.in);
int year=inpute.nextInt();
int month=inpute.nextInt();
int day=inpute.nextInt();
Date today=new Date(year,month,day);
}
}
class Date{
private int year;
private int month;
private int day;
private int [] mon_maxnum=new int[] {0,31,28,31,30,31,30,31,31,30,31,30,31};
Date(){

}
Date(int year,int month,int day){
this.year=year;
this.month=month;
this.day=day;
boolean a=checkInputValidity();
if(a)
getNextDate();
else
{
System.out.println("Date Format is Wrong");
return;
}

}
public int getYear(){
return year;
}
public void setYear(int year) {
this.year=year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month=month;
}
public int getDay (int day) {
return day;
}
public void setDay(int day) {
this.day=day;
}
public boolean isLeapYear(int year) {
if((year%100!=0&&year%4==0)||year%400==0)
return true;
else
return false;
}
public boolean checkInputValidity() {
if(isLeapYear(this.year))
mon_maxnum[2]=29;
if(year>=1900&&year<=2000&&month>=1&&month<=12&&day>=1&&day<=31&&day<=mon_maxnum[month])
return true;
else
return false;
}
public void getNextDate() {
if(isLeapYear(this.year))
mon_maxnum[2]=29;
if((day+1)>mon_maxnum[month]) {
if(month==12)
System.out.println("Next day is:"+(year+1)+"-"+
"1-1");
else
System.out.println("Next day is:"+year+"-"+(month+1)+"-1");
}
else
System.out.println("Next day is:"+year+"-"+month+"-"+(day+1));
}
}
个人思考：此题较完善的运用了类的功能，深入学习了类的定义及使用

编写程序性，实现对简单多项式的导函数进行求解。详见作业指导书。 OO作业3-3题目说明.pdf
输入格式：在一行内输入一个待计算导函数的表达式，以回车符结束。

输出格式:

如果输入表达式不符合上述表达式基本规则，则输出“Wrong Format”。
如果输入合法，则在一行内正常输出该表达式的导函数，注意以下几点：结果不需要排序，也不需要化简；

当某一项为“0”时，则该项不需要显示，但如果整个导函数结果为“0”时，则显示为“0”；
当输出结果第一项系数符号为“+”时，不输出“+”；
当指数符号为“+”时，不输出“+”；
当指数值为“0”时，则不需要输出“x^0”，只需要输出其系数即可。

代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
import java.util.regex.*;
public class Main {
public static void main(String[] args) {

Scanner inpute=new Scanner(System.in);
String s=inpute.nextLine();
if(s.indexOf('x')<0) {
System.out.println("0");
return;
}
s=s.replace(" ", "");
StringBuffer equation = new StringBuffer(s);
int a=equation.length();int i;
ArrayList<Integer> arry = new ArrayList<Integer>();
for( i=0;i<a;i++) {
if(equation.charAt(i)=='+'||equation.charAt(i)=='-') {
arry.add(i);
}
}
int [] arry1=new int [arry.size()];
for( i=0;i<arry.size();i++)
{
arry1[i]=arry.get(i);
}
for(i=0;i<arry1.length;i++) {
arry1[i]+=i;
}

for(i=0;i<arry1.length;i++) {
equation.insert(arry1[i]," ");
}
String equation1=equation.toString();
String[] arry2=equation1.split(" ");// 最后需要的数组

for(i=0;i<arry2.length;i++)
{
if(arry2[i].indexOf("x")<0) {
arry2[i]="";
}
}
for(i=0;i<arry2.length;i++) {
if(arry2[i]!="") {
String number=arry2[i];
int length1=number.length();
for(int j=0;j<length1;j++) {
if(i!=(arry2.length-1)&&(number.indexOf('x'))<0&&i!=0) {
arry2[i-1]=arry2[i-1]+arry2[i];
arry2[i]="";
break;
}
}
}
}
//System.out.println(Arrays.toString(arry2));
ArrayList<String> list=new ArrayList<>();

for(i=0;i<arry2.length;i++) {
if(arry2[i]!=""&&arry2[i]!=" ") {
list.add(shuchu(arry2[i]));
}
}
for(i=0;i<list.size();i++)
{
if(list.get(i).indexOf("w")>=0)
{
System.out.println("Wrong Format");
return;
}
}
for(i=0;i<list.size();i++)
System.out.print(list.get(i));

}
public static String shuchu(String a) {
Pattern p1=Pattern.compile("(-|\\+)(\\d+)(\\*)(x)(\\^)(-|\\+)(\\d+)"); // +4*x^-3
Pattern p2=Pattern.compile("(\\d+)(\\*)(x)(\\^)(-|\\+)(\\d+)"); //4*x^-3
Pattern p3=Pattern.compile("(-|\\+)(\\d+)(\\*)(x)(\\^)(\\d+)"); //-4*x^3
Pattern p4=Pattern.compile("(\\d+)(\\*)(x)(\\^)(\\d+)"); //4*x^3
Pattern p5=Pattern.compile("(-|\\+)(\\d+)(\\*)(x)"); //-4*x
Pattern p6=Pattern.compile("(\\d+)"); //12
Pattern p7=Pattern.compile("(\\d+)(\\*)(x)"); //4*x
Matcher m1=p1.matcher(a);
Matcher m2=p2.matcher(a);
Matcher m3=p3.matcher(a);
Matcher m4=p4.matcher(a);
Matcher m5=p5.matcher(a);
Matcher m6=p6.matcher(a);
Matcher m7=p7.matcher(a);
if(m1.find()) {
if(m1.group(2).charAt(0)-'0'==0||m1.group(7).charAt(0)-'0'==0) {
return "w";
}
String s1=m1.group(1)+m1.group(2);
int num=Integer.parseInt(s1);
String s2=(m1.group(6)+m1.group(7));
int num1=Integer.parseInt(s2);
int sum=num*num1;
num1=num1-1;
if(num1==0)
return sum+"";
else
return (sum+"*x^"+num1);
}
else if(m2.find()) {
String s=m2.group();
if(m2.group(1).charAt(0)-'0'==0||m2.group(6).charAt(0)-'0'==0) {
return "w";
}
String s1=(m2.group(1));
int length=m2.group().length();
String s2=(m2.group(5)+m2.group(6));
int num=Integer.parseInt(s1);
int num1=Integer.parseInt(s2);
int sum=num*num1;
num1=num1-1;
if(num1==0)
return(sum+"");
else
return (sum+"*x^"+num1);
}
else if(m3.find()) {
String s=m3.group();
if(m3.group(2).charAt(0)-'0'==0||m3.group(6).charAt(0)-'0'==0) {
return "w";
}
String s1=(m3.group(1)+m3.group(2));
// System.out.println(s1);
String s2=(m3.group(6));
//System.out.println(s2);
int num=Integer.parseInt(s1);
int num1=Integer.parseInt(s2);
int sum=num*num1;
num1=num1-1;
if(num1==0)
{
return(sum+"");
}
else if(sum<0)
return (sum+"*x^"+num1);
else
return ("+"+sum+"*x^"+num1);
}
else if(m4.find()) {
String s=m4.group();
if(m4.group(1).charAt(0)-'0'==0||m4.group(5).charAt(0)-'0'==0) {
return ("w");
}
String s1=(m4.group(1));
int length=m4.group().length();
String s2=(m4.group(5));
int num=Integer.parseInt(s1);
int num1=Integer.parseInt(s2);
int sum=num*num1;
num1=num1-1;
if(num1==0)
return (sum+"");
else
return (sum+"*x^"+num1);
}
else if(m5.find()) {
String s=m5.group();
if(m5.group(2).charAt(0)-'0'==0) {
return"w";
}
String s1=(m5.group(1)+m5.group(2));
int num=Integer.parseInt(s1);
return (num+"");
}
else if(m7.find()) {
String s1=(m7.group(1));
int num=Integer.parseInt(s1);
return (num+"");
}
else
return "";
}
}

个人思考：这题比较难，一开始我并不知道正则表达式这种方法，完全就是在拿数组进行硬分类讨论，导致十分复杂，后来运用了正则表达式后能解决正常求导问题，但有一些边界问题没有解决

posted @ 2021-04-04 18:14 LordFiber 阅读(67) 评论(0) 收藏举报

刷新页面返回顶部

Pta纠错

输出格式:

公告