java 代码中初试时间

转载

智能探索者之家 2025-01-05 13:21:38

文章标签 java 代码中初试时间 java System i++ 文章分类 Java 后端开发

6-1 计步器 (20分)

构造一个计步类StepRecorder，一个StepRecorder对象的构造函数包含一个整数参数，表示将某天认为有效天的最小步数。该类提供如下三个函数addDailySteps用于把每天的步数进行累计（包含有效和无效天），getActiveDays返回有效天数，getAverageSteps返回每天的平均步数，即总步数除以健身记录的天数（包含有效和无效天）。

main函数中，首先读入有效天的最小步数用于构造StepRecorder对象，然后读入天数n，然后读入每天的步数，最后输出活动天数和平均步数（直接取整）。
裁判测试程序样例：

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        StepRecorder sr = new StepRecorder(sc.nextInt());
        int n = sc.nextInt();
        for (int i=0;i<n;i++) {
            sr.addDailySteps(sc.nextInt());
        }
        System.out.println(sr.getActiveDays());
        System.out.println(sr.getAverageSteps());
    }
}
/* 请在这里填写答案 */

输入样例：
在这里给出一组输入。例如：

输出样例：
在这里给出相应的输出。例如：

2
10222

答案：

class StepRecorder{
	int minstep;
	int steps=0;
	int activedays=0;
	int days=0;

	public StepRecorder(int minstep) {
		this.minstep = minstep;
	}

	public int getMinstep() {
		return minstep;
	}

	public void setMinstep(int minstep) {
		this.minstep = minstep;
	}
	
	public int addDailySteps(int step)
	{
		days++;//记录总天数
		if(step>=getMinstep()) activedays++;//记录有效天数
		steps+=step;//记录总步数
		return steps;
	}
	public int getActiveDays()
	{
		return activedays;
	}
	public int getAverageSteps()
	{
		if(days==0) return 0;//运动天数为0 特殊情况
		else return steps/days;
	}
}

6-2 数群 (20分)

请设计如下相关接口和类：

1）接口IntegerGroup表示以某种方式定义的一组整数，称为数群，它可以为空，也可以包含一到多个整数。该接口包含唯一的函数boolean contains(int)，返回某个整数参数是否在这个IntegerGroup对象里。如group1是IntegerGroup类型的一个对象，包含两个数字-5和3，那么group1.contains(-5)返回true，group1.contains(2)返回false。请定义接口IntegerGroup

2）类Range是IntegerGroup的实现类，表示包含在最小值和最大值之间的所有连续整数（最小和最大值包含在内）。例如new Range(-3, 2)表示数群-3，-2，-1，0，1，2。请写出完整的Range类，包括必要的成员数据、构造函数、成员函数。假定最小值小于等于最大值。

3）类Enum也是IntegerGroup的实现类，表示多个分散整数构成的数群。例如new Enum(new int[]{1,3,5,2,-1})表示构造一个包含整数1,3,5, 2,-1的Enum对象，以整数数组作为参数。请完成类Enum，包含必要的成员数据、构造函数、成员函数。

4）类MultipleGroups表示一组IntegerGroup对象，并用一个列表来存储多个IntegerGroup对象，MultipleGroups类有函数add，用于添加IntegerGroup对象，有函数contains，该函数以一个整数作为参数，当且仅当该IntegerGroup对象中的一个或者多个IntegerGroup对象包含这个整数时返回true。例如MultipleGroups对象multiple1包含三个对象 new Range(5, 8), new Range(10, 12), new Enum(new int[]{1, 6})，那么对multiple1.contains的调用应当返回的值如下表所示，请完成类MultipleGroup，包含必要的成员数据、构造函数、成员函数。

java 代码中初试时间_i++

Main函数已经提供，其中构造了一个MultipleGroup对象，然后读入整数n，表示构造的IntegerGroup对象的个数，接着每行表示一个IntegerGroup对象，第一个整数表示对象类型，1为Range对象，2为Enum对象。对于Range对象来说，读入最小值和最大值，对于Enum对象来说，读入包含整数的个数，然后读入各个整数并构造为一个数组传入Enum的构造函数中。最后跟着5个测试数据，调用多个MultipleGroup对象的contains方法进行测试并输出结果。

裁判测试程序样例：

/* 请在这里填写答案 */
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        MultipleGroups mg = new MultipleGroups();
        for (int i=0;i<n;i++) {
            int t = sc.nextInt();
            IntegerGroup ng = null;
            if (t==1) {//Range
                ng = new Range(sc.nextInt(), sc.nextInt());
            } else {//Enum
                int len = sc.nextInt();
                int arr[] = new int[len];
                for (int j=0;j<len;j++)
                    arr[j] = sc.nextInt();
                    ng = new Enum(arr);
            }
            mg.add(ng);
        }
        for (int i=0;i<5;i++)
           System.out.println(mg.contains(sc.nextInt()));
        }
}

输入样例：
在这里给出一组输入。例如：

输出样例：
在这里给出相应的输出。例如：

false
false
true
false
false

答案：

interface IntegerGroup{
    public boolean contains(int a);
}

class Range implements IntegerGroup
{
    int max;
    int min;
    public Range(int max, int min) {
        this.max = max;
        this.min = min;
    }
    public int getMax() {
        return max;
    }
    public void setMax(int max) {
        this.max = max;
    }
    public int getMin() {
        return min;
    }
    public void setMin(int min) {
        this.min = min;
    }

    public boolean contains(int a)
    {
        if(a>=min&&a<=max)
            return true;
        else return false;
    }
}

class Enum implements IntegerGroup
{
    int num[];

    public Enum(int[] num) {
        this.num = num;
    }

    public boolean contains(int a)
    {
        boolean flag=false;
        for(int i=0;i<num.length;i++)
            if(a==num[i]) flag=true;
        return flag;
    }
}

class MultipleGroups implements IntegerGroup
{
    IntegerGroup group[];
    int num;
    int size;

    public MultipleGroups()
    {
        num=0;
        size=10;//数组初始大小
        group=new IntegerGroup[size];
    }
    public void add(IntegerGroup integerGroup)
    {
        if(num==size)//数组满扩容
        {
            IntegerGroup []narr=new IntegerGroup[size*2];
            System.arraycopy(group,0,narr,0,num);
            group=narr;
        }
        group[num]=integerGroup;
        this.num++;
    }

    public boolean contains(int a)
    {
        boolean flag=false;
        for(int i=0;i<num;i++)//注意不要越界
        {
            if(group[i].contains(a))
            {
                flag=true;
            }
            else flag=false;
        }
        return flag;
    }
}

待补充

6-3 sdust-Java-可实现多种排序的Book类 (20分)

设计Book类，要求：1）Book类的成员属性包括：书名name（String类型）、出版日期publishDate（Date类型）、定价price（double型）；2）为Book对象提供按出版日期、价格排序的两种方式，且能够满足测试程序代码中的输入输出要求（注意代码注释中的说明）。其中，类BookComparatorByPrice的排序功能是：将一组Book对象按照价格升序排序，如果价格相同，则按照书名字母顺序排列；类BookComparatorByPubDate的排序功能是：将一组Book对象按照出版日期降序排序。

裁判测试程序样例：

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        Book[] books = new Book[4];
        //1. 从键盘接收用户输入的4本书的名称（仅有英文字符构成）、出版日期（格式：1998-10-09）、价格，生成Book对象，构造包含4本书的数组
        for(int i=0;i<4;i++){
            String name = scan.next();
            String date_str = scan.next();
            Date date = null;
            //将键盘录入的日期字符串转换为Date
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            try {
                date = sdf.parse(date_str);
            } catch (ParseException e) {
                System.out.println("日期格式有误");;
            }

            double price = Double.parseDouble(scan.next());

            Book book = new Book(name, date, price);
            books[i] = book;
        }

        //2.将books按照出版日期降序排序；然后输出books
        Arrays.sort(books, new BookComparatorByPubDate());
        for(Book book:books){
            System.out.println(book);
        }

        //3.将books按照价格升序排序，如果价格相同，则按照书名字母顺序排列。然后输出books
        Arrays.sort(books, new BookComparatorByPrice());
        for(Book book:books){
            System.out.println(book);
        }

        scan.close();
    }

}

/* 请在这里填写答案 */

输入样例：

Java
2011-08-01
29
Python
2014-01-01
48
C
2004-09-08
17.5
DataBase
2012-09-17
17.5

输出样例：

书名:Python,定价:48.0
书名:DataBase,定价:17.5
书名:Java,定价:29.0
书名:C,定价:17.5
书名:C,定价:17.5
书名:DataBase,定价:17.5
书名:Java,定价:29.0
书名:Python,定价:48.0

答案：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
import java.util.Scanner;

class Book
{
    String name;
    Date publishDate;
    double price;
    public Book(String name, Date publishDate, double price) {
        this.name = name;
        this.publishDate = publishDate;
        this.price = price;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getPublishDate() {
        return publishDate;
    }
    public void setPublishDate(Date publishDate) {
        this.publishDate = publishDate;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    @Override
    public String toString()
    {
        return "书名:"+getName()+",定价:"+getPrice();
    }
}
class BookComparatorByPubDate implements Comparator{
    @Override
    public int compare(Object o1,Object o2)
    {
        Book b1=(Book) o1;
        Book b2=(Book) o2;
        if(b1.getPublishDate().compareTo(b2.getPublishDate())>0) return -1;//降序大于返回-1
        else return 1;//小于等于都返回1
    }
}

class  BookComparatorByPrice implements Comparator{
    @Override
    public int compare(Object o1,Object o2)
    {
        //int t=0;
        Book b1=(Book) o1;
        Book b2=(Book) o2;
        //大于返回1，小于等于都返回-1
//        if(b1.price>b2.price)
//            //t=1;
//            return 1;
//        else if(b1.price<b2.price)
//           // t=-1;
//            return -1;
//        else if(b1.price==b2.price)
//        {
            if(b1.name.compareTo(b2.name)==1)
                t=1;
            else if(b1.name.compareTo(b2.name)==-1)
                t=-1;
            else
                t=0;
//            if(b1.getName().compareTo(b2.getName())>0) return 1;
//            else return -1;
//        }
      //  return t;//这种写法非常差劲
        if(b1.getPrice()==b2.getPrice())
            return b1.getName().compareTo(b2.getName());//compareTo大于返回正整数小于返回负整数等于返回0
        else
        {
            if(b1.getPrice()>b2.getPrice()) return 1;//大于返回1
            else return -1;//小于等于都返回-1
        }
    }
}

7-1 超市贴花 (20分)

某家超市有一种促销手段，购买金额超过一定阈值就随机给一个贴花。贴花有不同种类的，种类以编号表示，编号是一个1到100之间的数字。当收集到连续编号的三张贴花时，就可以换一个小礼物。

小明经常去某家超市购物，积攒了不少贴花，你帮他看看，能换多少小礼物。

输入格式:
首先是一个正整数N（1<N<100），表示小明手上的贴花的数量。然后是N个正整数Pi（1<=Pi<=100），每个数字表示一张贴花的编号。

输出格式:
输出一个数字，表示小明可以换的小礼物的数量。如果不能换小礼物，就输出0。

输入样例:

6
3 2 4 6 6 4

输出样例:

2 3 4是一个组合，之后剩下的4 6 6不是连续的编号

答案：

//import java.util.Arrays;
//import java.util.Scanner;
//
//public class Main1{
//    public static void main(String[] args) {
//        Scanner sc = new Scanner(System.in);
//        int n=sc.nextInt();
//        int []a=new int[n];
//        for(int i=0;i<n;i++)
//        {
//            a[i]=sc.nextInt();
//        }
//
//        int lw=0;
//
//        for(int j=0;j<n;j+=2)
//        {
//            Arrays.sort(a, j, j+2);
//            //System.out.println(Arrays.toString(a));
//            if(a[j]+1==a[j+1]&&a[j+1]+1==a[j+2])
//                lw++;
//        }
//        System.out.println(lw);
//        sc.close();
//    }
//}
/*输入
6
3 2 4 6 6 4
 */
//输出 1



import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
            int n=cin.nextInt();
            int i;
            int a[]=new int[100];
            for(i=0;i<n;i++)
            {
                a[i]=cin.nextInt();
            }
            int count=1;
            int prize=0;
            Judge judge=new Judge();
            for(i=2;i<n;)
            {
                if(judge.f(a[i],a[i-1],a[i-2]))//每3个数字为1组
                {
                    prize++;
                    i=i+3;//跳过2个数字判断下一组
                }
                else
                {
                    i=i+1;//继续判断接下来的三个数字
                }
            }
        System.out.println(prize);
    }
}
class Judge{
    int a;
    int b;
    int c;
    int temp;

    public boolean f(int a,int b,int c)
    {
       //a,b,c升序排序
        int temp;
        if(a>b)
        {
            temp=a;
            a=b;
            b=temp;
        }
        if(a>c)
        {
            temp=a;
            a=c;
            c=temp;
        }
        if(b>c)
        {
            temp=b;
            b=c;
            c=temp;

        }
        if(a==b-1&&b==c-1)//判断3个数是否连续
            return true;
        return false;
    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。