本文档提供了50道Java编程练习题，包括小孩报数问题、班级排名、奖学金发放算法、生日相同的学生查找、扩号匹配等，旨在提升Java编程能力。每个题目都附带了详细的描述和示例输入输出，适合初学者和进阶者进行实战训练。
【Java】练习题（5）
41:小孩报数问题
总时间限制: 1000ms 内存限制: 65536kB
描述
有N个小孩围成一圈，给他们从1开始依次编号，现指定从第W个开始报数，报到第S个时，该小孩出列，然后从下一个小孩开始报数，仍是报到S个出列，如此重复下去，直到所有的小孩都出列（总人数不足S个时将循环报数），求小孩出列的顺序。
输入
第一行输入小孩的人数N（N<=64）
接下来每行输入一个小孩的名字(人名不超过15个字符)
最后一行输入asdasdasdasdW,S (W < N)，用逗号”,”间隔
输出
按人名输出小孩按顺序出列的顺序，每行输出一个人名
样例输入
5
Xiaoming
Xiaohua
Xiaowang
Zhangsan
Lisi
2,3
样例输出
Zhangsan
Xiaohua
Xiaoming
Xiaowang
Lisi
提示
可用链表来实现
代码
import java.util.LinkedList;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
List<String> children = new LinkedList<>();
for (int i = 0; i < n; i++) {
children.add(sc.next());
}
String[] ts1 = sc.next().split(",");
int a = Integer.parseInt(ts1[0]);
int b = Integer.parseInt(ts1[1]);
for (int i = 0; i < a - 1; i++) {
children.add(children.remove(0));
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < b - 1; j++) {
children.add(children.remove(0));
}
System.out.println(children.remove(0));
}
}
}
42:班级排名
总时间限制: 1000ms 内存限制: 65536kB
描述
信息科学技术学院年终评定讲学金，需要对整个年级的学生按照平均分数进行排名.
要求:根据输入的学号和平均成绩，按照平均成绩降序输出学号
如果平均成绩相同，按照输入的顺序输出。
输入
第一行为N,表示输入N位学生的信息，接着的N行输入学生信息，1<=N<=500
学生信息的格式为：学号 平均成绩
学号的长度小于10，平均成绩在1-100之间.
输出
按照平均成绩降序输出学号，如果平均成绩相同，按照输入顺序输出
样例输入
5
10948001 80
10948004 90
10948101 95
10948102 80
10948209 90
样例输出
10948101
10948004
10948209
10948001
10948102
提示
有些排序算法可能不能保证按照输入顺序输出
代码
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
Student[] s = new Student[a];
for (int i = 0; i < a; i++) {
s[i] = new Student(sc.next(), sc.nextInt());
}
Arrays.sort(s, (b, c) -> c.cj - b.cj);
for (Student student : s) {
System.out.println(student.sno);
}
}
}
class Student {
String sno;
int cj;
public Student(String sno, int cj) {
this.sno = sno;
this.cj = cj;
}
}
43:谁拿了最多奖学金
总时间限制: 1000ms 内存限制: 65536kB
描述
某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种，获取的条件各自不同：
- 院士奖学金，每人8000元，期末平均成绩高于80分（>80），并且在本学期内发表1篇或1篇以上论文的学生均可获得；
- 五四奖学金，每人4000元，期末平均成绩高于85分（>85），并且班级评议成绩高于80分（>80）的学生均可获得；
- 成绩优秀奖，每人2000元，期末平均成绩高于90分（>90）的学生均可获得；
- 西部奖学金，每人1000元，期末平均成绩高于85分（>85）的西部省份学生均可获得；
- 班级贡献奖，每人850元，班级评议成绩高于80分（>80）的学生干部均可获得；
只要符合条件就可以得奖，每项奖学金的获奖人数没有限制，每名学生也可以同时获得多项奖学金。例如姚林的期末平均成绩是87分，班级评议成绩82分，同时他还是一位学生干部，那么他可以同时获得五四奖学金和班级贡献奖，奖金总数是4850元。
现在给出若干学生的相关数据，请计算哪些同学获得的奖金总数最高（假设总有同学能满足获得奖学金的条件）。
输入
输入的第一行是一个整数N（1 <= N <= 100），表示学生的总数。接下来的N行每行是一位学生的数据，从左向右依次是姓名，期末平均成绩，班级评议成绩，是否是学生干部，是否是西部省份学生，以及发表的论文数。姓名是由大小写英文字母组成的长度不超过20的字符串（不含空格）；期末平均成绩和班级评议成绩都是0到100之间的整数（包括0和100）；是否是学生干部和是否是西部省份学生分别用一个字符表示，Y表示是，N表示不是；发表的论文数是0到10的整数（包括0和10）。每两个相邻数据项之间用一个空格分隔。
输出
输出包括三行，第一行是获得最多奖金的学生的姓名，第二行是这名学生获得的奖金总数。如果有两位或两位以上的学生获得的奖金最多，输出他们之中在输入文件中出现最早的学生的姓名。第三行是这N个学生获得的奖学金的总数。
样例输入
4
YaoLin 87 82 Y N 0
ChenRuiyi 88 78 N Y 1
LiXin 92 88 N N 0
ZhangQin 83 87 Y N 1
样例输出
ChenRuiyi
9000
28700
代码
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<Student> stList = new ArrayList<Student>();
int n = sc.nextInt();
for (int i = 1; i <= n; i++) {
stList.add(new Student(sc.next(), sc.nextInt(), sc.nextInt(), sc.next(), sc.next(), sc.nextInt()));
}
Collections.sort(stList);
System.out.println(stList.get(0).xm);
System.out.println(stList.get(0).jine);
System.out.println(Student.zongjine);
}
}
class Student implements Comparable<Student> {
String xm;
int qimo, pingyi;
String ganbu, xibu;
int lunwen;
static int zongjine = 0;
int jine = 0;
public Student(String xm, int qimo, int pingyi, String ganbu, String xibu, int lunwen) {
super();
this.xm = xm;
this.qimo = qimo;
this.pingyi = pingyi;
this.ganbu = ganbu;
this.xibu = xibu;
this.lunwen = lunwen;
jisuan();
zongjine += jine;
}
void jisuan() {
if (qimo > 80 && lunwen >= 1) {
jine += 8000;
}
if (qimo > 85 && pingyi > 80) {
jine += 4000;
}
if (qimo > 90) {
jine += 2000;
}
if (qimo > 85 && xibu.equals("Y")) {
jine += 1000;
}
if (pingyi > 80 && ganbu.equals("Y")) {
jine += 850;
}
}
@Override
public int compareTo(Student st) {
// TODO Auto-generated method stub
return st.jine - this.jine;
}
}
44:生日相同
总时间限制: 1000ms 内存限制: 65536kB
描述
在一个有180人的大班级中，存在两个人生日相同的概率非常大，现给出每个学生的学号，出生月日。试找出所有生日相同的学生。
输入
第一行为整数n，表示有n个学生，n<100。
此后每行包含一个字符串和两个整数，分别表示学生的学号（字符串长度小于10）和出生月(1<=m<=12)日(1<=d<=31)。
学号、月、日之间用一个空格分隔。
输出
对每组生日相同的学生，输出一行，
其中前两个数字表示月和日，后面跟着所有在当天出生的学生的学号，数字、学号之间都用一个空格分隔。
对所有的输出，要求按日期从前到后的顺序输出。
对生日相同的学号，按输入的顺序输出。
样例输入
5
00508192 3 2
00508153 4 5
00508172 3 2
00508023 4 5
00509122 4 5
样例输出
3 2 00508192 00508172
4 5 00508153 00508023 00509122
代码
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Map<Md, String> map1 = new TreeMap<Md, String>();
for (int i = 0; i < n; i++) {
String sno = sc.next();
int m = sc.nextInt();
int d = sc.nextInt();
Md md1 = new Md(m, d);
if (map1.containsKey(md1)) {
map1.put(md1, map1.get(md1) + " " + sno);
} else {
map1.put(md1, sno);
}
}
Set<Md> ks = map1.keySet();
for (Md k : ks) {
String v = map1.get(k);
if (v.contains(" ")) {
System.out.println(k.m + " " + k.d + " " + v);
}
}
}
}
class Md implements Comparable<Md> {
int m, d;
public Md(int m, int d) {
this.m = m;
this.d = d;
}
@Override
public int compareTo(Md o) {
return this.m == o.m ? this.d - o.d : this.m - o.m;
}
}
45:扩号匹配
总时间限制: 1000ms 内存限制: 65536kB
描述
判断一组匹配的左右扩号序列中，每一个右扩号与之相匹配成对的左扩号是整个扩号序列的第几个扩号。输出所有判断结果。
输入
输入有两行。
第一行输入一个整数（该整数必定是偶数），该整数表示扩号序列中一共有多少个扩号。
第二行输入用1和2分别代表左右扩号的扩号序列。例如输入序列11211222，表示扩号序列(()(()))。
输出
输出为一行。即挨个输出每个2（右扩号‘）’）与之相匹配的1（左扩号‘（’）在扩号序列中是第几个，用空格格开。
样例输入
4
1212
4
1122
6
112122
8
11211222
20
11211122122121122212
样例输出
1 3
2 1
2 4 1
2 5 4 1
2 6 5 9 4 12 15 14 1 19
提示
输入的扩号总数一定为偶数。输入的12序列必定是匹配的，1和2的个数相等，必为扩号总数的一半。
测试数据有多组，采用while()循环输入。
代码
import java.util.Scanner;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Stack<Integer> st=new Stack<>();
while (sc.hasNextInt()) {
int n = sc.nextInt();
String s = sc.next();
for (int i = 0; i < n; i++) {
char c=s.charAt(i);
if (c=='1') {
st.push(i+1);
}
else{
System.out.print(st.pop()+" ");
}
}
System.out.println();
}
}
}
46:集合合并
总时间限制: 3000ms 内存限制: 50000kB
描述
已知集合A与集合B，且第个集合内数据是唯一的。求A，B集合合并成新的集合C，要求C集合内的数据也是唯一的。并指出C集合的个数。
输入
三行，第一行分别为集合A，B的个数
第二行为A集合的数据
第三行为B集合的数据
输出
两行
第一行集合C的个数
第二行为C集合的数据
样例输入
4 5
12 34 56 78
34 67 89 34 76
样例输出
7
12 34 56 78 67 89 76
提示
数据小于30000
代码
import java.util.LinkedHashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int n = sc.nextInt();
Set<Integer> set1 = new LinkedHashSet<>();
for (int i = 0; i < m + n; i++) {
set1.add(sc.nextInt());
}
System.out.println(set1.size());
for (Integer k : set1) {
System.out.print(k + " ");
}
}
}
47:字符串排序
总时间限制: 1000ms 内存限制: 65536kB
描述
先输入你要输入的字符串的个数。然后换行输入该组字符串。每个字符串以回车结束，每个字符串少于一百个字符。如果在输入过程中输入的一个字符串为“stop”，也结束输入。
然后将这输入的该组字符串按每个字符串的长度，由小到大排序，按排序结果输出字符串。
输入
字符串的个数，以及该组字符串。每个字符串以‘\n’结束。如果输入字符串为“stop”，也结束输入.
输出
将输入的所有字符串按长度由小到大排序输出(如果有“stop”，不输出“stop”)。
样例输入
5
sky is grey
cold
very cold
stop
3
it is good enough to be proud of
good
it is quite good
样例输出
cold
very cold
sky is grey
good
it is quite good
it is good enough to be proud of
提示
根据输入的字符串个数来动态分配存储空间（采用new()函数）。每个字符串会少于100个字符。
测试数据有多组，注意使用while()循环输入。
代码
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNextInt()) {
int n = sc.nextInt();
sc.nextLine();
List<String> list1 = new ArrayList<>();
for (int i = 0; i < n; i++) {
String s = sc.nextLine();
if ("stop".equals(s)) {
break;
} else {
list1.add(s);
}
}
Collections.sort(list1, (a, b) -> a.length() - b.length());
for (String ss : list1) {
System.out.println(ss);
}
}
}
}
48:最远距离
总时间限制: 1000ms 内存限制: 65536kB
描述
给定一组点(x,y)，求距离最远的两个点之间的距离。
输入
第一行是点数n（n大于等于2）
接着每一行代表一个点，由两个浮点数x y组成。
输出
输出一行是最远两点之间的距离。
使用printf("%.4f\n", dis)输出距离值并精确到小数点后4位。
样例输入
6
34.0 23.0
28.1 21.6
14.7 17.1
17.0 27.2
34.7 67.1
29.3 65.1
样例输出
53.8516
提示
注意在内部计算时最好使用double类型，但在用scanf读取数据时只能用float类型的变量。
代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Point[] ps=new Point[n];
for (int i = 0; i < n; i++) {
ps[i]=new Point(sc.nextDouble(),sc.nextDouble());
}
double max=0;
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
double t=ps[i].dis(ps[j]);
if (t>max) {
max=t;
}
}
}
System.out.printf("%.4f\n",max);
}
}
class Point{
double x,y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double dis(Point p){
return Math.sqrt((this.x-p.x)*(this.x-p.x)+(this.y-p.y)*(this.y-p.y));
}
}
49:竞赛评分
总时间限制: 1000ms 内存限制: 65536kB
描述
现举行一次小竞赛,参赛的3支队伍,编号为1,2,3.每支队列轮流回答问题,如果回答正确,加10分;回答错误,扣10分;放弃回答不得分.经过多轮答题后,我们要统计各队的名次和得分.
输入
第一行为回答问题的轮次数n.
其余各行分别为1,2,3号队伍答题的结果,回答正确为right,错误为wrong,放弃为give-up.
输出
按名次输出各队的编号和得分.名次相同的在同一行输出,且编号小者靠前.
样例输入
4
right wrong give-up
right right right
wrong right right
right right right
样例输出
(3,30)
(1,20)(2,20)
代码
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Team[] teams=new Team[3];
for (int i = 0; i < 3; i++) {
teams[i]=new Team(i+1,0);
}
int n = sc.nextInt();
for (int i = 0; i < n; i++) {
for(int j=0;j<3;j++){
String st = sc.next();
if (st.equals("right")) {
teams[j].score+=10;
}
else if(st.equals("wrong")){
teams[j].score-=10;
}
}
}
Arrays.sort(teams,(x,y)->y.score-x.score);
System.out.print("("+teams[0].no+","+teams[0].score+")");
for(int i=1;i<3;i++){
if (teams[i].score<teams[i-1].score) {
System.out.println();
}
System.out.print("("+teams[i].no+","+teams[i].score+")");
}
}
}
class Team{
int no;
Integer score;
public Team(int no, Integer score) {
this.no = no;
this.score = score;
}
}
50:素数回文数的个数
总时间限制: 1000ms 内存限制: 65536kB
描述
求11到n之间（包括n），既是素数又是回文数的整数有多少个。
输入
一个大于11小于1000的整数n。
输出
11到n之间的素数回文数个数。
样例输入
23
样例输出
1
提示
回文数指左右对称的数，如：292，333。
代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int sum = 0;
for (int i = 11; i < n + 1; i++) {
if (ss(i) && hw(i)) {
sum++;
}
}
System.out.println(sum);
}
private static boolean ss(int i) {
for (int j = 2; j < i; j++) {
if (i % j == 0) {
return false;
}
}
return true;
}
private static boolean hw(int i) {
String s = i + "";
int len = s.length();
for (int j = 0; j < len / 2; j++) {
if (s.charAt(j) != s.charAt(len - 1 - j)) {
return false;
}
}
return true;
}
}
扫一扫
720
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
