首页 > 其他分享 >pta题目集1-3

pta题目集1-3

时间：2023-05-24 23:13:51浏览次数：39  
标签：题目 String int pta 空格 点菜 Dish new

  1. 前言：在完成这三个题目集之前，我对面向对象程序这几个字还没什么深入了解，甚至以为java和上学期学习的c语言没什么区别（落泪）。但当我真正着手这些题目时，才真正窥见一丝java的妙用！由于我的无知，第二，三次菜单计价程序都做的十分糟糕，以下二，三次菜单计价程序代码是和同学探讨思路之后自己重新写出的代码。这三个题目集对于知识点的考察循序渐进，但题量与难度却在题目集二是断崖式增大，让曾经的我无从下手（大哭）。
  2. 设计与分析

 题目集1

房产税费计算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

代码：

import java.util.Scanner;
public class Main{
    public static void main(String[] arges){
        Scanner input = new Scanner (System.in);
        int a,b,c;
        double d;
        a=input.nextInt();
        b=input.nextInt();
        c=input.nextInt();
        d=input.nextDouble();
        double x,y,z,q;
        if(a==1)
        {
            if(d<=90)
            {
                x=c*0.01;
            }
            else if(d<=144)
            {
                x=c*0.015;
            }
            else
            {
                x=c*0.03;
            }
        }
        else
        {
            x=c*0.03;
        }
        x=x*10000;
        y=b*0.0005*10000;
        z=3*d;
        q=d*1.36;
        System.out.print((float)x+" "+(float)y+" "+(float)z+" "+(float)q);
    }
    }
房产税费计算2022

踩坑心得：

在输入房屋面积的数据时使用了input.nextInt()和input.nextFloat()但都会报错;

输出时控制输出小数点为一位时会报错；

改进思路：就我而言这大概是最能代表这次题目集的题了。首先，这道题有点复杂，对比其他题目如游戏角色选择或判断三角形类型等，这题拥有庞大的计算量！不仅考察了java的不同数据类型的输入，还要使用if-else语句的选择。最重要的一点，这题在输出时需要将数据强制转换为float类型！这个小坑在那时狠狠的将我绊倒在java的学习之路！

7-6 学号识别

学校的学号由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"

代码：

import java.util.Scanner;
public class Main{
    public static void main(String[] args){
        String year,yuan,clas,num;
        Scanner input = new Scanner(System.in);
        String a = input.next();
        if(a.length()!=8){
            System.out.print("Wrong Format");
        }
        else{
            year = a.substring(0,2);
            yuan = a.substring(2,4);
            clas = a.substring(4,6);
            num = a.substring(6,8);
           if(yuan.equalsIgnoreCase("01")) {
            yuan = "材料学院";
        }
            else if(yuan.equalsIgnoreCase("02")) {
            yuan = "机械学院";
        }
            else if(yuan.equalsIgnoreCase("03")) {
            yuan = "外语学院";
        }
            else if(yuan.equalsIgnoreCase("20")) {
            yuan = "软件学院";
        }
            else {
        System.out.print("Wrong Format");
            return;}
            System.out.print("入学年份：20"+year+"年\n"+"学院："+yuan+"\n"+"班级："+clas+"\n"+"学号："+num);
            
        }
    }
}
学号识别

踩坑心得：

在输入时需要判断输入字符串的长度已处理异常数据。

需要用到substring方法对输入数据进行分段分析。

改进思路：

在输入数据时使用if(a.length()!=8) else的语句用于判断输入是否为异常数据。

对正确的输入用如下操作进行分段，“year = a.substring(0,2); yuan = a.substring(2,4); clas = a.substring(4,6); num = a.substring(6,8);”处理起来更加方便！

题目集2

菜单计价程序1

代码：

1.菜品类

Dish

2.菜单类

class Menu{
    Dish[] dishes = new Dish[4];
    Dish searthDish(String dishName){
        dishes[0] = new Dish();
        dishes[1] = new Dish();
        dishes[2] = new Dish();
        dishes[3] = new Dish();
        dishes[0].name ="西红柿炒蛋";
        dishes[1].name = "清炒土豆丝";
        dishes[2].name = "麻婆豆腐";
        dishes[3].name = "油淋生菜";
        dishes[0].unit_prince = 15;
        dishes[1].unit_prince = 12;
        dishes[2].unit_prince = 12;
        dishes[3].unit_prince = 9;
        for(int i=0;i<4;i++){
            if(dishName.equals(dishes[i].name)){
                return dishes[i];
            }
        }
        return null;
    }
}
Menu

3.点菜记录类

class Record{
    Dish d = new Dish();
    int portion;
    int getPrice(){
        return d.getPrice(portion);
    }
}
Record

4.订单类

class Order {
    Record[] records =new Record[100];
    int count = 0;
    int getTotalPrice(){
        int sum=0;
        for(int i=0;i<count;i++){
            sum=sum+records[i].getPrice();
        }
        return sum;
    }
    Record addARecord(String dishName,int portion){
        Record rd1 = new Record();
        rd1.d.name = dishName;
        rd1.portion = portion;
        count++;
        return rd1;
    }

}
Order

5.主类

public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        Menu menu1 = new Menu();
        Order order1 = new Order();
        String in;
        int j=0;
        while(true){
            in = input.nextLine();
            if(in.equals("end")){
                break;//判断是否结束输入
            }
            String[] tem1 = in.split(" ");
            order1.records[order1.count] = new Record();//创建一个记录的数组，便于录入订单中
            order1.records[order1.count] = order1.addARecord(tem1[0],Integer.parseInt(tem1[1]));//点菜记录的录入
        }
        /*
        判断是否存在；
        */
        Dish dish1;
        for(;j<order1.count;j++){
            dish1 = menu1.searthDish(order1.records[j].d.name);
            if(dish1==null){
                System.out.println(order1.records[j].d.name+" "+"does not exist");
            }
            else{
                order1.records[j].d.unit_prince = dish1.unit_prince;
            }
        }
        System.out.println(order1.getTotalPrice());
    }
}
Main

踩坑心得：最初我用java写出的这题的代码非常的臃肿难看（因为对类的使用十分的生疏,）当时我写出的menu，order类如同一个摆设，主体部分全在主类中，整个代码看下来就如同一个营养不良的孩子，头很大但身子很小。很遗憾我并没有将之前的代码保存下来，不然可博众人一笑。

改进思路：之后我重新完善了各个类，例如移除在主类中的总价计算，而是将其添加为Record类的方法，还有在Order类中添加count属性用于记录订单数以此为主类减负。最后主类只留下两部分，一是点菜信息的输入，二是点菜信息的识别与价格的输出，代码整体变得非常的简洁。

菜单计价程序2

输入格式:

菜品记录格式：

菜名+英文空格+基础价格

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

点菜记录格式：
序号+英文空格+菜名+英文空格+份额+英文空格+份数
注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。

删除记录格式：序号 +英文空格+delete


最后一条记录以“end”结束。

输出格式:

按顺序输出每条订单记录的处理信息，

每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品*份数，序号是之前输入的订单记录的序号。
如果订单中包含不能识别的菜名，则输出“** does not exist”，**是不能识别的菜名

如果删除记录的序号不存在，则输出“delete error”

最后输出订单上所有菜品的总价（整数数值），

本次题目不考虑其他错误情况，如：菜单订单顺序颠倒、不符合格式的输入、序号重复等。

 代码：

1.主类

import java.util.Scanner;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        Menu mu = new Menu();
        Order od = new Order();
        int j,l;
        j=l=0;
        String[] inputt = new String[1000];
        int incount = 0;
        Dish tt;
        while(true){
            int count = 0;
            String st = sc.nextLine();
            for(int i=0;i<st.length();i++){
                String te = st.substring(i,i+1);
                if(te.equals(" ")){//通过空格判断输入的内容
                    count++;
                }
            }
            if(st.equals("end"))//判断是否结束输入
                break;
            if(count==1){//输入菜单或者删除
                String[] temp = st.split(" ");
                if(temp[1].equals("delete")){
                    if(!od.delARecordByOrderNum(Integer.parseInt(temp[0]))){//判断删除的记录是否存在
                        System.out.println("delete error;");
                        incount++;
                    }
                }else{
                    mu.dishs[l] = mu.addDish(temp[0],Integer.parseInt(temp[1]));
                    l++;
                }
            }
            if(count==3){//输入点菜记录
                String[] temp1 = st.split(" ");
                od.records[j]=od.addARecord(Integer.parseInt(temp1[0]),temp1[1],Integer.parseInt(temp1[2]),Integer.parseInt(temp1[3]));
                tt = mu.searthDish(od.records[j].d.name);

                if(tt==null){//菜名不存在
                    System.out.println(od.records[j].d.name+" does not exist");
                }else{
                    od.records[j].d.unit_price = tt.unit_price;
                    System.out.println(od.records[j].orderNum+" "+od.records[j].d.name+" "+od.records[j].d.getPrice(od.records[j].portion));
                }//输出菜名和价格
                j++;
            }
        }
        System.out.print(od.getTotalPrice());
    }
}
主类

2.菜品类

class Dish {
    String name;//菜品名称
    int unit_price;    //单价
    int num;

    int getPrice(int portion) {
        int peic = 0;
        switch (portion) {
            case 1:
                peic = (int)unit_price * num;
                break;
            case 2:
                peic = Math.round((float) (unit_price * 1.5)) * num;
                break;
            case 3:
                peic = (int) (unit_price * 2) * num;
                break;
        }
        return peic;//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
    }
}
菜品类

3.菜单类

class Menu {
    Dish[] dishs = new Dish[10];//菜品数组，保存所有菜品信息
    int count = 0;
    Dish searthDish(String dishName){
        Dish temd = null;
        for(int i=count-1;i>=0;i--){
            if(dishName.equals(dishs[i].name)){
                temd = dishs[i];
                break;
            }
        }
        if(temd==null){
            System.out.println(dishName+" does not exist");
        }
        return temd;
    }//根据菜名在菜谱中查找菜品信息，返回Dish对象。
    Dish addDish(String dishName,int unit_price){
        Dish dh = new Dish();
        dh.name = dishName;
        dh.unit_price = unit_price;
        count++;
        return dh;
    }//添加一道菜品信息
}
菜单类

4.点菜记录类

class Record {
    int orderNum;//序号\
    Dish d = new Dish();//菜品\
    int portion;//份额（1/2/3代表小/中/大份）\
    int exist = 1;
    int getPrice(){
        return d.getPrice(portion);
    }//计价，计算本条记录的价格\
}
点菜记录类

5.订单类

class Order {
    Record[] records = new Record[1000];//保存订单上每一道的记录
    int count = 0;
    int getTotalPrice(){
        int sum=0;
        for(int i=0;i<count;i++){
            if(records[i].exist==0)
                continue;
            sum=sum+records[i].getPrice();
        }
        return sum;
    }//计算订单的总价
    Record addARecord(int orderNum,String dishName,int portion,int num){
        Record rd1 = new Record();
        rd1.d.name = dishName;
        rd1.orderNum = orderNum;
        rd1.portion = portion;
        rd1.d.num = num;
        count++;
        return rd1;
    }//添加一条菜品信息到订单中。
    boolean delARecordByOrderNum(int orderNum){
        if(orderNum>count||orderNum<=0){
            //System.out.println("delete error");
            return false;
        }else
            records[orderNum-1].exist=0;
        return true;
    }//根据序号删除一条记录
    void findRecordByNum(int orderNum){

    }//根据序号查找一条记录
}
订单类

踩坑心得：

与点菜1不同的是，点菜二新增了删除点菜记录的功能，输入菜单的功能，点菜的数量，并且要在每天点菜记录对应的位置输出菜名和这条记录的价格！在实现删除订单功能时，还要考虑删除的订单不存在的情况，在删除失败时输出“delete error”。

改进思路：

先写一个while（true）死循环为主类的主体。用String st = sc.nextLine();每次输入一行内容，再用一段循环计算这行输入有多少个空格，通过空格数量来判断输入类型是菜单输入还是点菜记录等等。本题共有两种情况：空格为1和空格为3。其中空格为1时有菜单输入和删除记录两种情况，空格数为3时只有点菜记录这个情况。

题目集3

 菜单计价程序-3

输入格式:

桌号标识格式：table + 序号 +英文空格+ 日期（格式：YYYY/MM/DD）+英文空格+ 时间（24小时制格式： HH/MM/SS）

菜品记录格式：

菜名+英文空格+基础价格

如果有多条相同的菜名的记录，菜品的基础价格以最后一条记录为准。

点菜记录格式：序号+英文空格+菜名+英文空格+份额+英文空格+份数注：份额可输入（1/2/3）， 1代表小份，2代表中份，3代表大份。

删除记录格式：序号 +英文空格+delete

代点菜信息包含：桌号+英文空格+序号+英文空格+菜品名称+英文空格+份额+英文空格+分数

最后一条记录以“end”结束。

输出格式:

按输入顺序输出每一桌的订单记录处理信息，包括：

1、桌号，格式：table+英文空格+桌号+“:”+英文空格

2、按顺序输出当前这一桌每条订单记录的处理信息，

每条点菜记录输出：序号+英文空格+菜名+英文空格+价格。其中的价格等于对应记录的菜品\*份数，序号是之前输入的订单记录的序号。如果订单中包含不能识别的菜名，则输出“\*\* does not exist”，\*\*是不能识别的菜名

如果删除记录的序号不存在，则输出“delete error”

最后按输入顺序一次输出每一桌所有菜品的总价（整数数值）格式：table+英文空格+桌号+“:”+英文空格+当前桌的总价

本次题目不考虑其他错误情况，如：桌号、菜单订单顺序颠倒、不符合格式的输入、序号重复等，在本系列的后续作业中会做要求

代码：

主类：

import java.util.Scanner;
import java.util.Calendar;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Menu mu = new Menu();
        Table[] tablemes = new Table[10];
        int j = 0;//菜单数
        int l = 0;//订单数
        int k = 0;//代点菜数
        Dish tt;
        //int sum = 0;
        int cntTable = 0;//桌号
        int count;
        String[] temp;
        int a1,a2,a3,a4,a5;

        while (true) {
            String st = sc.nextLine();
            temp = st.split(" ");
            if(st.equals("end"))
                break;
            count = temp.length;
            if (count == 2) {//一个空格
                //String[] temp1 = st.split(" ");
                if (temp[1].equals("delete")) {//第二个为delete
                    a1 = Integer.parseInt(temp[0]);
                    int c = tablemes[cntTable].odt.delARecordByOrderNum(a1);
                    tablemes[cntTable].sum-=c;
                } else {//菜单添加
                    a2 = Integer.parseInt(temp[1]);
                    mu.dishs[j] = mu.addDish(temp[0], a2);
                    j++;
                }
                //continue;
            }
            else if (count == 4) {//三个空格
                //String[] temp2 = st.split(" ");
                if (temp[0].equals("table")) {//桌号
                    cntTable++;//跳过0;
                    l = 0;
                    tablemes[cntTable] = new Table();
                    //tablemes[cntTable].tableDtime = st;
                    tablemes[cntTable].AheadProcess(st);

                    System.out.println("table " + cntTable + ": ");
                } else {//增加订单的情况；
                    a3 =Integer.parseInt(temp[0]);
                    a4 = Integer.parseInt(temp[2]);
                    a5=Integer.parseInt(temp[3]);
                    tablemes[cntTable].odt.addARecord(a3, temp[1],a4 , a5);
                    tt = mu.searthDish(temp[1]);
                    if (tt != null) {
                        tablemes[cntTable].odt.records[l].d = tt;
                        int a = tablemes[cntTable].odt.records[l].getPrice();
                        System.out.println(tablemes[cntTable].odt.records[l].orderNum + " " + tt.name + " " +a );
                        tablemes[cntTable].sum +=a;
                    }
                    l++;
                }
                //continue;
            }

            else if (count == 5) {//代点菜
                //String[] temp3 = st.split(" ");
                a1 = Integer.parseInt(temp[1]);
                a2 = Integer.parseInt(temp[3]);
                a3 = Integer.parseInt(temp[4]);
                tablemes[cntTable].odt.addARecord( a1, temp[2], a2, a3);
                tt = mu.searthDish(temp[2]);
                if (tt != null) {
                    tablemes[cntTable].odt.records[l].d.unit_price = tt.unit_price;
                    int b = tablemes[cntTable].odt.records[l].getPrice();
                    System.out.println(temp[1] + " table " + tablemes[cntTable].tableNum + " pay for table " + temp[0] + " " + b);
                    tablemes[cntTable].sum += b;
                }
                l++;
            }
            //st = sc.nextLine();

        }
        for (int i = 1; i < cntTable + 1; i++) {
            tablemes[i].Gettottalprice();
        }
    }
}
主类

菜品类：

class Dish {
    String name;//菜品名称
    int unit_price;    //单价
    //int num;

    int getPrice(int portion) {
        int peic = 0;
        if (portion == 1) {
            peic = unit_price ;
        } else if (portion == 2) {
            peic = Math.round((float) (unit_price * 1.5)) ;
        } else if (portion == 3) {
            peic = (unit_price * 2) ;
        }
        return peic;//计算菜品价格的方法，输入参数是点菜的份额（输入数据只能是1/2/3，代表小/中/大份）
    }
}
菜品类

菜单类：

class Menu {
    Dish[] dishs = new Dish[10];//菜品数组，保存所有菜品信息
    int count = 0;
    Dish searthDish(String dishName){
        Dish temd = null;
        for(int i=count-1;i>=0;i--){
            if(dishName.equals(dishs[i].name)){
                temd = dishs[i];
                break;
            }
        }
        if(temd==null){
            System.out.println(dishName+" does not exist");
        }
        return temd;
    }//根据菜名在菜谱中查找菜品信息，返回Dish对象。
    Dish addDish(String dishName,int unit_price){
        Dish dh = new Dish();
        dh.name = dishName;
        dh.unit_price = unit_price;
        count++;
        return dh;
    }//添加一道菜品信息
}
菜单类

点菜记录类：

class Record {
    int orderNum;//序号\
    //int AntherOrderNum;
    Dish d = new Dish();//菜品\
    int num = 0;//数量
    int portion;//份额（1/2/3代表小/中/大份）\
    //int exist = 1;
    int getPrice(){
        return d.getPrice(portion)*num;
    }//计价，计算本条记录的价格\
}
点菜记录类

订单类：

class Order {
    Record[] records = new Record[10];//保存订单上每一道的记录
    int count = 0;//订单数量
    //int forcount = 0;//代点菜的数量
    /*int getTotalPrice(){
        int sum=0;
        for(int i=0;i<count;i++){
            if(records[i].exist==0)
                continue;
            sum=sum+records[i].getPrice();
        }
        return sum;
    }//计算订单的总价*/
    void addARecord(int orderNum,String dishName,int portion,int num){
        records[count] = new Record();
        records[count].d.name = dishName;
        records[count].orderNum = orderNum;
        records[count].portion = portion;
        records[count].num = num;
        count++;
    }//添加一条菜品信息到订单中。
    /*Record TakeOdfor(int AnotherNUm,int orderNum,String dishName,int portion,int num){
        Record rd2 = new Record();
        rd2.d.name = dishName;
        rd2.orderNum = orderNum;
        rd2.portion = portion;
        rd2.d.num = num;
        rd2.AntherOrderNum = AnotherNUm;
        //forcount++;
        return rd2;
    }*/
    int delARecordByOrderNum(int orderNum){
        if(orderNum>count||orderNum<=0){
            System.out.println("delete error;");
            return 0;
        }else {
            return records[orderNum - 1].getPrice();
        }
    }//根据序号删除一条记录
}
订单类

桌类：

class Table {
    int tableNum;
    String tableDtime;
    int year,month,day,week,hh,mm,ss;
    int sum = 0;//一桌价格 ；
    // boolean f = true;
    Order odt = new Order();
    //Order odre = new Order();
    float discnt = -1;
    void Gettottalprice(){
        if(discnt>0){
            sum = Math.round(sum*discnt);
            System.out.println("table " + tableNum + ": " + sum);
        }else {
            System.out.println("table " + tableNum + " out of opening hours");
        }
    }
    void AheadProcess(String tableDtime){
        this.tableDtime = tableDtime;
        processTime();
        discount();
        //CheckAtime();
    }


    void processTime(){//处理时间
        String[] temp = tableDtime.split(" ");
        tableNum = Integer.parseInt(temp[1]);
        String[] temp1 = temp[2].split("/");
        String[] temp2 = temp[3].split("/");

        year = Integer.parseInt(temp1[0]);
        month = Integer.parseInt(temp1[1]);
        day = Integer.parseInt(temp1[2]);

        Calendar c = Calendar.getInstance();
        c.set(year, (month-1), day);
        week = c.get(Calendar.DAY_OF_WEEK);
        if(week==1)
            week = 7;
        else
            week--;
        hh = Integer.parseInt(temp2[0]);
        mm = Integer.parseInt(temp2[1]);
        ss = Integer.parseInt(temp2[2]);

    }
    //void CheckAtime(){
    // f= !(discnt < 0);
    // }
    void discount(){
        if(week>=1&&week<=5)
        {
            if(hh>=17&&hh<20)
                discnt=0.8F;
            else if(hh==20&&mm<30)
                discnt=0.8F;
            else if(hh==20&&mm==30&&ss==0)
                discnt=0.8F;
            else if(hh>=11&&hh<=13||hh==10&&mm>=30)
                discnt=0.6F;
            else if(hh==14&&mm<30)
                discnt=0.6F;
            else if(hh==14&&mm==30&&ss==0)
                discnt=0.6F;
        }
        else
        {
            if(hh>=10&&hh<=20)
                discnt= 1.0F;
            else if(hh==9&&mm>=30)
                discnt= 1.0F;
            else if(hh==21&&mm<30||hh==21&&mm==30&&ss==0)
                discnt= 1.0F;
        }
    }
}
桌类

踩坑心得：

此题目总体跨度较大，但解题思路还是大差不差，具体的陷阱在桌类的构造。既要用正则表达式处理时间，还要用处理好的时间来计算折扣，而且总价格的计算也改为计算每桌的价格。

改进思路：在主类末尾写出循环用于输出每桌的价格。将带点菜功能写在主类中便于进行对数据的处理。在点菜二中的类大部分可以直接拿来用！

       3.总结：

这几次pta的作业给了我很大的触动，首先就是可持续性改进，在点菜一中写下的代码，在接下来的点菜二点菜三中都只要做小小的改进甚至不需要改进就能拿来用，之后只需要随着题目的改动来写出新的类和改动主类就行，这几个题目不仅增强了我对类的属性，方法的思考，而且深化了我对面对对象程序设计的理解，同时，对于idea的使用，比如调试，插件的安装与查找等技能，也得到了很好的锻炼！我的独立思考能力也逐渐增强，对写代码的热情也越来越高！我认为还需改进的地方就是代码的健壮性不足，仍需要多多钻研。我认为实验题目也同样可以让学生写一篇博客来回顾自己的学习经历，对于pta题目的话我认为可以在每次作业之后开一个补题集给学生不断的进行改进。以上是我的全部内容。

 

标签：题目,String,int,pta,空格,点菜,Dish,new
From： https://www.cnblogs.com/henhendexie/p/17426845.html

相关文章

  • Java PTA第1~3次题目集总结
    一.前言1.第一次题目集的知识点主要就是让我们初步意识到java与c语言不同的输入输出关键词用法以及一些相对固定的代码块（比如publicstaticvoidmain（String[]args）{}）；题量相对较多但在承受范围之内；难度较为简单。2.第二次题目集的知识点除了跟第一次一样的之外，在7-1菜单题目里......
  • 前三次题目总结
    1，前言前三次题目集涉及的知识点主要包括输入输出的考察，循环的应用以及if-else的运用，类的创建，方法的调用，封装等等；题量适中，第一次九道入门的题目，第二次四道，第三次七道；难度而言第一次题目集由于有着C语言的基础还是较为简单的，第二次作业开始难度就上来了，如果平时没有花时间在学习jav......
  • 题目集1~3的总结性
    一、前言：总结三次题目集的知识点、题量、难度等情况题目集1：知识点：计算，单位换算，键盘录入，数组题量：9难度：中等题目集2：知识点：键盘录入，数组，类的创建，对象的创建和使用，java日期类，递归方法，条件语句和循环语句的使用题量：4难度：偏难题目集3：知识点：键盘录入，数组，类的创......
  • PTA前三次题目集总结BLOG
    一、前言本学期开展了面向对象程序设计这门课程，开始了Java语言的学习。现对前三次作业的题目集做概括分析： 1.第一次作业共九道题目，难度一般，均为基础题目，主要涉及到的主要是对java语法的认识，以及顺序结构、循环结构、选择结构等知识，这些与C语言并无太大区别，所以完成起来较为顺......
  • 题目集1~3总结
    一.前言Java编程语言是当今最流行的编程语言之一，由于其跨平台性、面向对象性和安全性等特点，受到广泛的应用。作为一名计算机专业的学生，在学习Java编程语言时，我们需要完成多个作业来巩固所学知识。在前三次Java作业中，我们已经学习了Java的基础知识和常用技术，通过完成这些作业，我们......
  • Blog-1-PTA题目集1~3
    前言：题目集1中共有9道题目，对应的题目及难度分别为：1.身体质量指数（BMI）测算（一星）2.长度质量计量单位换算（一星）3.奇数求和（一星）4.房产税费计算2022（一星）5.游戏角色选择（一星）6.学号识别（一星）7.巴比伦法求平方根近似值（一星）8.二进制数值提取（一星）9.判断三角形类型（一星）题目集2中共有4......
  • oop题目集1~3的总结性Blog
    1）前言第一次作业：7-1主要是从控制台输入问题，和嵌套循环。7-2的要点是数据的精确度，严格的输出。7-3是数组的调用，循环的使用。7-4要点在与if和else的使用和标准的输入和输出。7-5主要是switch方法的使用7-6主要是substring的调用和字符串长度的判断length()和.equals()的使用7-7主要......
  • 题目集1~3的总结
    1.前言在这三次的题目集中，主要涉及到了面向对象的相关知识点，包括类、对象、构造函数、封装、继承和多态等。我们学习了很多有关面向对象编程和软件设计的知识。这三次的题目集中，题目量和难度都有一定的增加。难度最大的题目集3中，我们需要设计一个完整的菜单计价系统，这一份题目集......
  • 前三次pta题目集分析
    （1）前言：我们是这个学期才开始学Java，上个学期学的是C，坦白说，我的C学的不好，然后这个学期的Java开始也是很吃力，编写代码很不熟练，这次pta的三个题目集，难度是在一步步增加的。第一次的题目一共是有9题，都算比较简单，知识点都是基础一些的计算等基本知识，我也拿到了满分。第二次的题目集......
  • 页面中调用swf 时allowScriptAccess 参数
    <paramname="allowScriptAccess"value="always"/>使用allowScriptAccess使Flash应用程序可与其所在的HTML页通信。此参数是必需的，因为fscommand()和getURL()操作可能导致JavaScript使用HTML页的权限，而该权限可能与Flash应用程序的权限不同。这与跨域安全性有......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99