java题目三

已于 2023-06-06 17:42:47 修改
阅读量319 收藏 3
点赞数 1
分类专栏： java题目 文章标签： java Powered by 金山文档
于 2023-03-15 20:06:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74161592/article/details/129562181
版权

一，比较两个元素的大小，在程序编写时会经常遇到，特别是在进行元素排序时，“比大小”必不可少。编程高手们总喜欢想着“一劳永逸”，编写一个程序可以适用不同情况，而且容易拓展。小王同学以编程高手为目标，想编写一个类，其中包含了各种各样的“比大小”方法，而且名称全部相同，调用形式也基本一样，小王同学已经将程序的主类设计完成，并添加了注释，请你帮他完善各个功能类的代码。

//比较两个对象的大小，每个类的对象大小比较规则不尽相同 
import java.util.Scanner;
public class Main {
 public static Scanner reader=new Scanner(System.in);
 public static void main(String[] args) {
  Main ct=new Main(); //新建一个Main对象ct，
  Point p1=new Point(),p2=new Point();//定义两个Point型对象p1，p2；
  ct.input(p1,p2);//输入p1和p2对象的成员变量值
  System.out.println(ct.compare(p1,p2));//输入对象p1和p2的比较结果，如果p1大，输出true，否则输出false

  Fraction f1=new Fraction(),f2=new Fraction();//新建两个Fraction型对象f1，f2；
  f1.input(); f2.input();//输入f1，f2对象的成员变量值；
  System.out.println(ct.compare(f1,f2));//输入对象f1和f2的比较结果，如果f1大，输出true，否则输出false
///
  MyArray a1=new MyArray();
  MyArray a2=new MyArray();
  ct.input(a1, a2);
  System.out.println(ct.compare(a1,a2));
 }

//输入对比的对象
 void input(Point a,Point b){
  a.input(); b.input();
 }
 void input(Fraction a,Fraction b){
  a.input(); b.input();
 }
 void input(MyArray a,MyArray b){
  a.input(); b.input();
 }
 public boolean compare(Point a,Point b){
  if(a.bigTo(b))return true;
  else return false;
 }
 public boolean compare(Fraction f1,Fraction f2){
  if(f1.compare(f2)==true)return true;
  else return false;
 }
 public boolean compare(MyArray m1,MyArray m2){
  if(MyArray.compare(m1,m2)>=0)return true;
  else return false;
 } 
}
class Point{//创建一个point类
 int x,y; //对象x，y
 public void input(){
  Scanner reader=Main.reader;
  x=reader.nextInt(); y=reader.nextInt();//输入x，y
 }
 public boolean bigTo(Point p){//定义一个bigTo的方法
  if(this.x*this.y>=p.x*p.y)return true;
  else return false;
 } 
}

说明1：Fraction类的对象大小比较规则：根据分数值的大小进行比较；MyArray类的对象大小比较规则：认为对应位置大于对方数组元素的个数多于小于对方数组元素个数的那个数组更大，若元素缺失，则补0。

说明2：所有数据都是合法的

说明3：在Fraction类与MyArray类中读入数据时必须使用Main.reader对象作为数据输入对象。

输入

两个点，两个分数，两个数组

输出

三个判断结果

样例输入 Copy

1 2

3 4

1 2

3 4

2

1 2

3

2 1 -1

样例输出 Copy

false

false

true

import java.util.Scanner;
public class Main {
    public static Scanner reader=new Scanner(System.in);
    public static void main(String[] args) {
        Main ct=new Main();//新建一个Main对象ct，
        Point p1=new Point(),p2=new Point();//定义两个Point型对象
        ct.input(p1,p2);//调用构造方法，输入p1和p2对象的成员变量值
        System.out.println(ct.compare(p1,p2));//输入对象p1和p2的比较结果，如果p1大，输出true，否则输出false

     Fraction f1=new Fraction(),f2=new Fraction();//新建两个Fraction型对象f1，f2；
     ct.input(f1,f2);//输入f1，f2对象的成员变量值；
     System.out.println(ct.compare(f1,f2));//输入对象f1和f2的比较结果，如果f1大，输出true，否则输出false
       
        MyArray a1=new MyArray();
        MyArray a2=new MyArray();
        ct.input(a1, a2);
        System.out.println(ct.compare(a1,a2));
    }
    void input(Point a,Point b){
        a.input(); b.input();
    }
    void input(Fraction a,Fraction b){
        a.input(); b.input();
    }
    void input(MyArray a,MyArray b){
        a.input(); b.input();
    }
    public boolean compare(Point a,Point b){
        if(a.bigTo(b))return true;
        else return false;
    }
    public boolean compare(Fraction f1,Fraction f2){
        if(f1.compare(f2)==true)return true;
        else return false;
    }
    public boolean compare(MyArray m1,MyArray m2){
        if(MyArray.compare(m1,m2)>=0)return true;
        else return false;
    }
}
class Point{//创建一个point类，比较点的大小
    int x,y; //对象x，y
    public void input(){
    Scanner reader=Main.reader;
    x=reader.nextInt(); y=reader.nextInt();//输入x，y
}
   public boolean bigTo(Point p){//定义一个bigTo的方法
   if(this.x*this.y>=p.x*p.y)return true;
   else return false; 
} 
class MyArray{//创建一个MyArray的类，比较数组大小
    int [] arr;
    public void input(){
        Scanner reader=Main.reader;
        int n = reader.nextInt();//输入数组元素个数和数组元素
        this.arr = new int[n];
        for (int i = 0; i < n; i++) {
            this.arr[i] = reader.nextInt();
        }
    }
    public static int compare(MyArray p1,MyArray p2){
        int cnt1=0,cnt2=0;
        int sum = Math.max(p1.arr.length,p2.arr.length);
        for (int i = 0; i < sum; i++) {
            if(i<p1.arr.length && i<p2.arr.length){
                if(p1.arr[i]>p2.arr[i]) cnt1++;
                else if(p1.arr[i]<p2.arr[i]) cnt2++;
            }
            if(i<p1.arr.length && p1.arr[i]>0) cnt1++;
            else if(i<p1.arr.length && p1.arr[i]<0) cnt2++;
            if(i<p2.arr.length && p2.arr[i]>0) cnt2++;
            else if(i<p2.arr.length && p2.arr[i]<0) cnt1++;
        }
        return (cnt1-cnt2);
    }
}
class Fraction{
    int son,mom;
    public void input(){
        Scanner reader=Main.reader;
        son=reader.nextInt(); mom=reader.nextInt();
    }
    public boolean compare(Fraction p){

        if((double)this.son/(double)this.mom>(double)p.son/(double)p.mom || Math.abs((double)this.son/(double)this.mom-(double)p.son/(double)p.mom)<1e-6)return true;
        else return false;
    }
}

二冬奥会自由式滑雪大跳台决赛的计分规则是：六名裁判给分（0-100分，整数分数），去掉一个最高分，去掉一个最低分，取平均值作为（除以4.0）参数选手得分（double类型）；每位选手可以出场三次，取最高的两次得分和作为该选手的最终总分。

假设有12名选手参加自由式滑雪大跳台决赛，请你编写Java程序，根据每位选手每次出场的得分，计算选手总分，并按照总分降序排列输出选手的基本信息。如果总分相同，则按姓名升序排序。

说明1：字符串s与t比较大小使用s.compareTo(t)，若返回值<0，则s串<t串，若返回值>0，则s串>t串，若返回值为0，则s、t串相等。

说明2：计算每次的平均分时记得除以4.0而不是4，否则会视为整除，无法得到正确的结果

输入

每个选手姓名、国家、三次六位裁判的评分

输出

按选手总分降序输出每个选手的姓名、国家与总分

样例输入 Copy

a5

SUI

92 35 100 7 65 6

65 90 4 78 43 45

61 5 35 51 52 62

a1

DEN

73 54 94 64 39 38

63 35 48 61 91 52

40 68 47 59 82 30

a9

CHN

49 62 78 84 79 37

52 5 38 14 33 39

13 44 13 25 87 42

a12

JPN

61 13 75 51 89 35

89 85 33 6 62 8

60 50 55 54 24 9

a6

USA

99 52 8 48 47 9

85 37 64 22 26 7

36 29 41 67 89 81

a4

GER

5 68 66 34 32 17

48 50 71 51 37 65

59 28 51 28 64 86

a11

USA

64 41 9 14 96 94

29 89 33 20 60 13

22 88 28 36 74 28

a3

AUS

86 48 70 19 1 38

17 14 89 74 81 40

56 39 42 71 47 47

a8

CHN

18 71 46 78 51 23

94 77 85 76 90 7

59 46 66 59 63 29

a10

GBR

6 80 41 64 47 56

0 5 68 77 95 6

85 33 96 97 72 31

a2

ISL

95 96 11 44 12 41

36 6 68 71 89 7

31 41 16 3 82 35

a7

SWE

9 77 79 93 21 93

88 24 92 55 56 56

97 27 27 13 98 15

样例输出 Copy

a8,CHN,138.75

a7,SWE,131.25

a10,GBR,123.5

a1,DEN,113.5

a5,SUI,107.5

a4,GER,104.0

a12,JPN,102.5

a3,AUS,101.0

a9,CHN,98.0

a6,USA,95.25

a11,USA,94.75

a2,ISL,93.5

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

public class Main{
    public static void main(String[] args) {
        Player[] cp = new Player[12];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 12; i++) {
            String name = sc.next();
            String country = sc.next();

            int [] sco = new int[6];

            for (int i1 = 0; i1 < 6; i1++) {
                sco[i1] = sc.nextInt();
            }
            Arrays.sort(sco,0, sco.length);
            double[] sum = new double[3];
            for (int i1 = 1; i1 < 5; i1++) {
                sum[0] += (double)sco[i1];
            }
            sum[0] /= 4.0;

            for (int i1 = 0; i1 < 6; i1++) {
                sco[i1] = sc.nextInt();
            }
            Arrays.sort(sco,0, sco.length);
            for (int i1 = 1; i1 < 5; i1++) {
                sum[1] += (double)sco[i1];
            }
            sum[1] /= 4.0;

            for (int i1 = 0; i1 < 6; i1++) {
                sco[i1] = sc.nextInt();
            }
            Arrays.sort(sco,0, sco.length);
            for (int i1 = 1; i1 < 5; i1++) {
                sum[2] += (double)sco[i1];
            }
            sum[2] /= 4.0;
            Arrays.sort(sum,0,sum.length);
            cp[i] = new Player(name,country,(sum[1]+sum[2]));
        }
        Arrays.sort(cp, new Comparator<Player>() {
                    public int compare(Player o1, Player o2) {
                        if(Math.abs(o1.getScore()-o2.getScore())<1e-6){
                            return o1.getName().compareTo(o2.getName());//分数相等
                        }else{
                            if((o2.getScore()-o1.getScore())>0) return 1;
                            else if((o2.getScore()-o1.getScore())<0) return -1;
                            else return 0;
                        }
                    }
        });
        for (int i = 0; i < 12; i++) {
            System.out.println(cp[i].getName()+","+cp[i].getCountry()+","+cp[i].getScore());
        }
    }
}
class Player{
    private String name;
    private String country;
    private double score;

    public Player() {
    }

    public Player(String name, String country, double score) {
        this.name = name;
        this.country = country;
        this.score = score;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCountry() {
        return country;
    }


    public void setCountry(String country) {
        this.country = country;
    }


    public double getScore() {
        return score;
    }


    public void setScore(double score) {
        this.score = score;
    }


}

三，某村庄有一口公共水井，为了保护该水井及饮用水的质量，当地规定当该水井内的水量不高于100时，禁止取水6小时，在此期间，水井水量自动恢复到最大容量1000；如果预计村民当次取水后水量低于100，则拒绝该村民本次取水。

其实每个村民自家也有口水井，自家的水井容量各不相同，范围在(100,200]内。村民优先去公共水井取水，若发现公共水井禁止取水或因容量不够拒绝取水时，再从自家水井取水。

自家水井容量不高于100时，禁止取水1小时，在此期间，水井水量自动恢复到初始水量；如果预计村民当次取水后水量低于100，则允许该村民本次从自家水井取水至水井容量到100。

请模拟两个村民用水情况：先设置公共水井水量及两位村民自家水井容量，再模拟村民1取水，村民2取水，村民1再次取水，村民2再次取水的情形。村民每次取水时需输入年、月、日、时、分、秒和取水量，若成功从公共水井取水则输出“public:m”形式，m表示公共水井剩余水量；若成功从自家水井取水则输出“private:n”形式，n表示自家水井剩余水量； 若没有取到水，则输出“wait”。

输入

公共水井初始水量（可以比1000小），两位村民自家水井水量（最大容量，也是初始水量），两位村民两次交替取水情况

输出

每次取水后的情况

样例输入 Copy

1000 150 200

2022 3 1 18 25 30 800

2022 3 1 20 25 20 150

2022 3 1 23 25 19 100

2022 3 2 6 25 25 150

样例输出 Copy

public:200

private:100

public:100

public:850

import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Well pub = new Well(sc.nextInt(),6*3600);
        Well Vlg1 = new Well(sc.nextInt(),3600);
        Well Vlg2 = new Well(sc.nextInt(),3600);
        for (int i = 0; i < 4; i++) {
            Time t = new Time(sc.nextInt(),sc.nextInt(),sc.nextInt(),sc.nextInt(),sc.nextInt(),sc.nextInt());
            int water = sc.nextInt();
            if(pub.DrWater(water,t)){
                System.out.println("public:"+pub.getNowW());
            }else if(i%2==0){
                if(Vlg1.DrWater(water,t)){
                    System.out.println("private:"+Vlg1.getNowW());
                }else{
                    System.out.println("wait");
                }
            }else{
                if(Vlg2.DrWater(water,t)){
                    System.out.println("private:"+Vlg2.getNowW());
                }else{
                    System.out.println("wait");
                }
            }



        }

    }
}
class Well{
    private int maxW;
    private int nowW;
    private int waitTime;
    private Time time;
    boolean GetWater = true;
    public boolean DrWater(int num,Time t){
        if(GetWater){
            if(nowW-num > 100){
                nowW -= num;
                return true;
            }else if(nowW-num==100){
                nowW = 100;
                time = t;
                GetWater = false;
                return true;
            }else if(waitTime==3600){
                nowW = 100;
                time = t;
                GetWater = false;
                return true;
            }
        }else if(time.sub(t)>=waitTime){
            if(waitTime==3600) {
                nowW = maxW;
            }else{
                nowW = 1000;
            }
            GetWater=true;
            return DrWater(num,t);
        }
        return false;
    }
    public Well() {
    }
    public Well(int maxW, int nowW,int waitTime) {
        this.maxW = maxW;
        this.nowW = nowW;
        this.waitTime = waitTime;
    }
    public Well(int maxW,int waitTime) {
        this.maxW = maxW;
        this.nowW = maxW;
        this.waitTime = waitTime;
    }
    public int getMaxW() {
        return maxW;
    }
    public void setTime(Time time) {
        this.time = time;
    }
    public Time getTime() {
        return this.time;
    }
    public void setMaxW(int maxW) {
        this.maxW = maxW;
    }
    public int getNowW() {
        return nowW;
    }
    public void setNowW(int nowW) {
        this.nowW = nowW;
    }


}
class Time{
    private int year=0;
    private int month=0;
    private int day=0;
    private int hour=0;
    private int minute=0;
    private int second=0;


    public Time() {
    }

    public Time(int year, int month, int day, int hour, int minute, int second) {
        this.year = year;
        this.month = month;
        this.day = day;
        this.hour = hour;
        this.minute = minute;
        this.second = second;
    }

    public long sub(Time t2){
        LocalDateTime dateTime = LocalDateTime.of(this.year, this.month, this.day, this.hour, this.minute, this.second);
        long timestamp = dateTime.toEpochSecond(ZoneOffset.UTC);
        LocalDateTime dateTime2 = LocalDateTime.of(t2.getYear(), t2.getMonth(), t2.getDay(), t2.getHour(), t2.getMinute(), t2.getSecond() );
        long timestamp2 = dateTime2.toEpochSecond(ZoneOffset.UTC);
        return timestamp2 - timestamp;
    }
    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() {
        return day;
    }
    public void setDay(int day) {
        this.day = day;
    }
    public int getHour() {
        return hour;
    }
    public void setHour(int hour) {
        this.hour = hour;
    }
    public int getMinute() {
        return minute;
    }

    public void setMinute(int minute) {
        this.minute = minute;
    }
    public int getSecond() {
        return second;
    }
    public void setSecond(int second) {
        this.second = second;
    }


}

四，一元二次方程的根，在整数范围内无解时，可以扩展到在实数范围内求解，如果在实数范围内无解，还可以扩展到复数范围内求解。请你根据一个一元二次方程的系数，求其在各类数范围内的解。

输入

n和n组一元二次方程的系数(整数）

输出

整数、实数（输出四舍五入保留2位小数）、复数（实部、虚部输出时均四舍五入保留2位小数）范围内的解，有整数解时不必输出实数、复数解，有实数解时不必输出复数解；若两个解相同，只输出1个，若两个解不同，按降序输出，本题定义复数的大小关系时不考虑虚数单位i。

样例输入 Copy

4

1 1 1

1 2 1

1 3 1

1 0 1

样例输出 Copy

Complex:-0.50+0.87i,-0.50-0.87i

Integer:-1

Real:-0.38,-2.62

Complex:i,-i

import java.util.Scanner;

public  class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            Equation f1 = new Equation(sc.nextInt(),sc.nextInt(),sc.nextInt());
            f1.getAns();
        }
    }
}
class Equation{
    private int a;
    private int b;
    private int c;
    private double det;
    public Equation() {
    }

    public Equation(int a, int b, int c) {
        this.a = a;
        this.b = b;
        this.c = c;
        this.det = 1.0*b*b-4.0*a*c;
    }
    public void getAns(){
        if(a!=0) {
            if (det == 0) {
                double ans = -1.0 * b / (2.0 * a);
                if (ans == Math.round(ans)) {//整数
                    System.out.printf("Integer:%d\n", Math.round(ans));
                } else {
                    System.out.printf("Real:%.2f\n", ans);
                }
            } else if (det > 0) {
                double ans1 = (-1.0 * b + Math.sqrt(this.det)) / (2.0 * a);
                double ans2 = (-1.0 * b - Math.sqrt(this.det)) / (2.0 * a);
                if (ans1 == Math.round(ans1) && ans2 == Math.round(ans2)) {//整数
                    System.out.printf("Integer:%d,%d\n", Math.round(ans1), Math.round(ans2));
                } else if (ans1 == Math.round(ans1) && ans2 != Math.round(ans2)) {
                    System.out.printf("Integer:%d\n", Math.round(ans1));
                } else if (ans1 != Math.round(ans1) && ans2 == Math.round(ans2)) {
                    System.out.printf("Integer:%d\n", Math.round(ans2));
                } else {
                    System.out.printf("Real:%.2f,%.2f\n", ans1, ans2);
                }
            } else if (det < 0) {
                double t = -1.0 * b / (2.0 * a);
                double ur = Math.sqrt(4.0 * a * c - 1.0 * b * b) / (2.0 * a);
                if (Math.abs(t - 0) < 1e-6 && Math.abs(ur - 1) > 1e-6) {//实部0 虚部不为1
                    if(ur== Math.round(ur)){
                        System.out.printf("Complex:%di,-%di\n", Math.round(ur), Math.round(ur));
                    }else {
                        System.out.printf("Complex:%.2fi,-%.2fi\n", ur, ur);
                    }
                } else if (Math.abs(t - 0) < 1e-6 && Math.abs(ur - 1) < 1e-6) {//实部0 虚部1
                    System.out.print("Complex:i,-i\n");
                } else if (Math.abs(t - 0) > 1e-6 && Math.abs(ur - 1) < 1e-6) {//实部不为0 虚部1
                    if(t==Math.round(t)){
                        System.out.printf("Complex:%d+i,%d-i\n", Math.round(t), Math.round(t));
                    }else {
                        System.out.printf("Complex:%.2f+i,%.2f-i\n", t, t);
                    }
                } else if(t==Math.round(t) && ur!=Math.round(ur)){
                    System.out.printf("Complex:%d+%.2fi,%d-%.2fi\n", Math.round(t), ur, Math.round(t), ur);
                }else if(t!=Math.round(t) && ur==Math.round(ur)){
                    System.out.printf("Complex:%.2f+%di,%.2f-%di\n", t, Math.round(ur), t, Math.round(ur));
                }else if(t==Math.round(t) && ur==Math.round(ur)){
                    System.out.printf("Complex:%d+%di,%d-%di\n", Math.round(t), Math.round(ur), Math.round(t), Math.round(ur));
                }else{
                    System.out.printf("Complex:%.2f+%.2fi,%.2f-%.2fi\n", t, ur, t, ur);
                }
            }
        }else{
            double ans = -1.0*c/b;
            if(ans == Math.round(ans)){
                System.out.printf("Integer:%d\n",Math.round(ans));
            }else{
                System.out.printf("Real:%.2f\n",ans);
            }
        }
    }
    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public int getB() {
        return b;
    }


    public void setB(int b) {
        this.b = b;
    }

    public int getC() {
        return c;
    }


    public void setC(int c) {
        this.c = c;
    }


    //ax^2 + bx + c = 0;
}

五，定义一个小车类Car，其初始位置为(0,0)，属性包括：当前位置，行驶速度，行驶朝向（东1、南2、西3、北4）；方向变化：直行(1)、左转(2)、右转(3)；速度变化（正数为加速，负数为减速）。

约束条件：(1)采用直角坐标系，上北下南左西右东；(2)速度为0时，车辆停止，减速无效；(3)速度达到20时，加速无效。

输入

小车的初始位置(x,y)、初始速度(v)和初始朝向(f)，时刻数量（<=1000），每个时刻内的方向变化(c)、速度变化(s)

输出

当前小车的位置

样例输入 Copy

0 0 0 1

10

1 1 1 1 1 1 1 0 1 0 1 0 2 0 1 0 1 2 1 -1

样例输出 Copy

15,15

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner reader = new Scanner(System.in);
        Car a = new Car(reader.nextInt(),reader.nextInt(),reader.nextInt(),reader.nextInt());
        int n=reader.nextInt();
        for (int i = 0; i <n; i++) {
            a.changeDirection(reader.nextInt());
            a.changV(reader.nextInt());
            a.changXY();
        }
        a.Print();
    }
}
class Car{
    private int x;
    private int y;
    private int v;
    private int d;
    public Car(){

    }
    public  Car(int x,int y,int v,int d){
        this.x=x;
        this.y=y;
        this.v=v;
        this.d=d;
    }
    public void setX(int x) {
            this.x = x;
        }
    public void setY(int y) {
            this.y = y;
        }
    public void setV(int v) {
            this.v = v;
        }
    public void setD(int d) {
            this.d = d;
        }
    public void changeDirection(int d){
        if(d==2){
            if(this.d==1) {
                this.d = 4;
            }
            else if(this.d==2){
                this.d=1;
            }
            else if(this.d==3){
                this.d=2;
            }
            else if(this.d==4){
                this.d=3;
            }
        }
        if(d==3){
            if(this.d==1){
                this.d=2;
            }
            else if(this.d==2) {
                this.d = 3;
            }
            else if(this.d==3){
                this.d=4;
            }
            else if(this.d==4){
                this.d=1;
            }
        }
    }
    public void changV(int cv){
        v+=cv;
        if(v>20){
            v=20;
        }
        if(v<0){
            v=0;
        }
    }
    public void changXY(){
        if(d==1){
            x+=v;
        }
        if(d==3){
            x-=v;
        }
        if(d==4){
            y+=v;
        }
        if(d==2){
            y-=v;
        }
    }
    public void Print(){
        System.out.println(x+","+y);
    }
}
Sakura_—
关注
专栏目录
评委评分，有6个评委为参赛的选手打分，分数为0-100的整数分，去掉一个最高分和一个最低分后 的4个评委平均值(不考虑小数部分)
vv的博客
07-06 2642
public static void main(String[] args) { int [] array = new int[6] ; Scanner scanner = new Scanner(System.in) ; for (int i = 0; i <array.length; i++) { System.out.println("请输入第"+(i+1)+"号评委打分(0-100): "); array [i] = scanner.n.
静态和有参
yjj1123456的博客
09-29 3550
1、村庄 村庄类Village有一个int类型的peopleNumber变量，用于描述村庄的人口数量，String类型的name用于描述村庄的名称。定义一个【有参】构造函数对村庄名称进行初始化。定义setPeopleNumber（int p）对村庄人口进行设置，定义getPeopleNumber( )对村庄人口进行获取。 在主类Land的main方法中定义两个名为赵庄，马家河子的村庄，人口分别设置为80和120. 输出两个村庄的人口数量。 package shiyan_04; public
java毕业设计北京冬奥会志愿服务小程序[附源码]
php-毕业源码设计
03-23 461
北京成为首个既举办过夏季奥运会又举办冬季奥运会的城市，这不仅体现了中国的综合国力和国际影响力，也展现了中国对于奥林匹克运动的支持和承诺。在如此宏大的背景之下，志愿服务作为奥运会成功举办的重要支撑力量，其重要性不言而喻。开发一个针对北京冬奥会志愿服务的小程序，旨在提高志愿者工作的效率，确保各项服务顺利进行，具有十分重要的现实意义。后端由Spring Boot提供支持，前端由Vue.js构建，数据存储和管理通过MySQL和Navicat实现，整个开发流程由Maven进行管理，并在Tomcat服务器上运行。
java计算机毕业设计冬奥会志愿者报名系统（附源码+springboot+开题+论文+部署）
最新发布
杰简程序毕设
04-08 741
此外，该系统的研究还有助于推动相关领域的技术创新和应用发展，为其他大型赛事的志愿者报名工作提供有益的参考和借鉴。本研究旨在开发一套功能全面、操作便捷的冬奥会志愿者报名系统，通过在线报名、录取情况查询、风采展示等功能模块的实现，为冬奥会志愿者提供高效、便捷的报名服务。同时，通过系统的应用，提升赛事组织的信息化水平，优化志愿者管理流程，确保赛事的顺利进行。最后，本研究还将总结系统设计与实现的经验教训，提炼出可推广应用的技术方法和思路，为类似大型赛事的志愿者报名工作提供有益的参考和借鉴。
基于JavaEE的奥运专题网站社区毕业设计论文
QQ79856539的博客
03-21 356
随着人们生活质量越来越高，与世界全球化所带来的影响，人们对体育关注度越来越高，奥运会自然成了人们生活中的热门话题，随之带来的体育相关的产业也应运而生，包括体育明星，代言品牌之类的数不甚数，当人们看到奥运记录被一次次破除，惊叹人类体能极限的时候，无不想对过往数据回味以及对当前赛事进行前瞻，此时，关于奥运会的专题网络社区会满足人们的这些需求，本篇论文设计和实现了奥运专题网络社区管理系统的设计与实现。整个系统从功能实用性、操作简单性，界面友好性出发，为奥运专题网络社区的管理提供了一个可视化操作平台。
java课后编程题目.doc
12-01
Java 编程题目解析 在 Java 课程中，编程题目扮演着非常重要的角色，它可以帮助学生巩固所学的知识，提高编程能力和问题解决能力。以下是对给定文件的标题、描述、标签和部分内容的解析，从中可以提取出多个知识点...
Java笔试题目.xls
08-25
Java笔试题目.xls
java笔试题目
02-27
3. **集合框架**：Java集合框架是存储和管理对象的重要工具，包括List（ArrayList、LinkedList）、Set（HashSet、TreeSet）、Map（HashMap、TreeMap）等接口及其实现。考生需理解它们的特点和使用场景，以及遍历、...
Java题目-远程.docx
07-10
Java题目-远程.docx 从给定的文件信息中，我们可以提取出以下几个知识点： 1. Peak_Set 的概念：Peak_Set 是指一个序列中所有峰值元素的集合。峰值元素是指序列中某个元素，如果它大于序列中所有小于其的元素。...
java上机考试题目.doc
04-05
3、getMinute（），返回当前的分钟数 4、getAmPm（），返回上午还是下午 5、toString（），表示时间的字符串，例如“6:27 PM” 6、isWorkTime（），判断当前时间是否属于工作时间，工作时间9:00 AM到5:00 PM 用户...
java程序-奥运倒计时
05-11
一个Java写的小程序，支持北京奥运
Java小白 请五位评委（“冰人”格文，“穆大叔”，“魔术师”约翰逊，“大鲨鱼奥尼尔以及麦迪”）打分，控制台输入5个10以内的整数，中间用逗号隔开（10，9，9，8，10）最后计算5位评委给出的分
Lin_bai_的博客
10-15 634
请五位评委（“冰人”格文，“穆大叔”，“魔术师”约翰逊，“大鲨鱼奥尼尔以及麦迪”）打分，控制台输入5个10以内的整数，中间用逗号隔开（10，9，9，8，10）最后计算5位评委给出的分数之和 import sun.reflect.generics.tree.Tree; import java.util.*; public class HashMapTest { public static void main(String[] args) { Scanner scanner =
蓝桥杯 ADV-296 算法提高 奥运会开幕式
荔枝的FM
02-09 618
算法提高 奥运会开幕式 时间限制：1.0s 内存限制：256.0MB 问题描述 　　学校给高一（三）班分配了一个名额，去参加奥运会的开幕式。每个人都争着要去，可是名额只有一个，怎么办？班长想出了一个办法，让班上的所有同学（共有n个同学）围成一圈，按照顺时针方向进行编号。然后随便选定一个数m，并且从1号同学开始按照顺时针方向依次报数，1, 2, …, m，凡报到m的同学，都要主动退出圈...
c语言比较数组中的元素大小,C语言之数组的冒泡排序
weixin_39760295的博客
05-17 6117
原标题：C语言之数组的冒泡排序在实际开发中，有很多场景需要我们将数组元素按照从大到小(或者从小到大)的顺序排列，这样在查阅数据时会更加直观，例如：l 一个保存了班级学号的数组，排序后更容易分区好学生和坏学生；l 一个保存了商品单价的数组，排序后更容易看出它们的性价比。对数组元素进行排序的方法有很多种，比如冒泡排序、归并排序、选择排序、插入排序、快速排序等，其中最经典最需要掌握的是「冒泡排序」。以从...
java元素之间大小比较,java-判断相同和对象比较大小
weixin_33182922的博客
03-21 446
java中判断相同有两种方式：第一种：使用==直接判断相同，它适用于两个变量之间、一个变量和一个对象之间相比较。如：int a=3,c=3;Integer b=new Integer(3);System.out.println(a==c);System.out.println(a==b);输出结果为：truetrue第二种：使用equals()函数比较，它适用于两个对象之间、一个对象和一个变量之间...
滑雪 java_滑雪算法（贪心算法）的java和c的实现 | 学步园
weixin_35391606的博客
02-15 370
java实现：public class Demo {/*** 计算区域最长长度** Michael喜欢滑雪这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，* 而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道在一个区域中最长底滑坡。* 区域由一个二维数组给出。数组的每个数字代表点的高度* 下面是一个例子* 1 2 3 4 5* 16 17...
编写程序模拟两个村庄共用同一口井水。编写一个 Village 类，该类有一个静态的 int 型成员变量 waterAmount，用于模拟井水的水量。在主类 Land 的 main()方法中创建两个村庄
m0_56117066的博客
10-09 6442
3）Land类，主类-》public class Land，-》main，Village wuzhuang = new Village()，wuzhuang.SetPeopelNumber(XXXX);或者 Village xwuzhuang = new Village(XXX)， Village 2 = …所以，Village这个类就有两个动作，即两个成员函数——改变、查看，还得有个变量来表示人口，int peopleNumber。2）改变（动作）：Village发出来的；
经典C面试真题精讲
热门推荐
weixin_30566063的博客
03-27 1万+
第一章 灵魂--指针 101. p++ 请分析下述代码的输出结果 int main() { char* p1 = "China"; char* p2, * p3; p2 = (char*)malloc(20); memset(p2, 0, 20); while(*p2++ = *p1++); ...
2017、2018面试分享（js面试题记录）记得点赞分享哦；让更多的人看到~~
weixin_34032827的博客
03-19 2200
2017面试分享（js面试题记录） 1. 最简单的一道题 '11' * 2 'a8' * 3 var a = 2, b = 3; var c = a+++b; // c = 5 2. 一道this的问题 var num = 10; var obj = { num:8, ...
Java笔试必备：基础题目详解
"Java笔试题目，涵盖基础语法、类、内部类、继承、异常处理、线程、集合、I/O及虚拟机等多个方面。题目来源于网络整理和面试反馈，部分网上题目实用性存疑。" 在Java编程语言中，笔试题目常常涉及到一系列的基础...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值