43:小孩报数问题
描述
有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.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
LinkedList<String> child = new LinkedList<String>();
int n = in.nextInt();
in.nextLine();
for (int i = 1; i <= n; i++)
{
String s = in.nextLine();
child.add(s);
}
char[] ws = in.next().toCharArray();
int w = ws[0] - '0' - 1;
int s = ws[2] - '0';
s--;
while (child.size() != 0)
{
w += s;
w = w % child.size();
System.out.println(child.get(w));
child.remove(w);
}
}
}LinkedList ：相当于数据结构中的链表
ArrayList：基于数组实现
LinkedList 列表的一些函数
add用法：boolean add(e)：在链表后添加一个元素，如果成功，返回true，否则返回false
addFirst(e)：在链表头部插入一个元素
addLast(e)：在链表尾部添加一个元素
add(index,element)：在指定位置插入一个元素
remove用法： remove()；移除链表中第一个元素
boolean remove(Object o)：移除链表中指定的元素
remove(index)：移除链表中指定位置的元素
removeFirst()：移除链表中第一个元素，与remove类似
removeLast()：移除链表中最后一个元素
boolean removeFirstOccurrence(Object o)：移除链表中第一次出现所在位置的元素
boolean removeLastOccurrence(Object o)：移除链表中最后一次出现所在位置的元素get用法：get(int index)：按照下边获取元素
getFirst()：获取第一个元素
getLast()：获取最后一个元素peek用法： peek()：获取第一个元素，但是不移除
peekFirst()：获取第一个元素，但是不移除
peekLast()：获取最后一个元素，但是不移除push(E e)：与addFirst一样，实际上它就是addFirst
pop()：与removeFirst一样，实际上它就是removeFirst
poll()：查询并移除第一个元素
length——数组的属性
length()——String的方法 （获取字符串长度）
size()——集合的方法 (获取泛型集合有多少个元素)
44:班级排名
描述
信息科学技术学院年终评定讲学金，需要对整个年级的学生按照平均分数进行排名.
要求:根据输入的学号和平均成绩，按照平均成绩降序输出学号
如果平均成绩相同，按照输入的顺序输出。
输入
第一行为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.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int num;
int score;
int [] nn = new int[1000];
int [] ss = new int[1000];
for(int i=0;i<n;i++)
{
nn[i] = in.nextInt();
ss[i] = in.nextInt();
}
for(int j=0;j<n;j++)
{
for(int k=j+1;k<n;k++)
{
if(ss[k]<=ss[j])
{
score = ss[j];
ss[j] = ss[k];
ss[k] = score;
num = nn[j];
nn[j] = nn[k];
nn[k] = num;
}
}
}
for(int i=0;i<n;i++)
{
System.out.println(nn[n-i-1]);
}
}
} //这种做法与小老鼠再排队类似
45:谁拿了最多奖学金
描述
某校的惯例是在每学期的期末考试之后发放奖学金。发放的奖学金共有五种，获取的条件各自不同：
1) 院士奖学金，每人8000元，期末平均成绩高于80分（>80），并且在本学期内发表1篇或1篇以上论文的学生均可获得；
2) 五四奖学金，每人4000元，期末平均成绩高于85分（>85），并且班级评议成绩高于80分（>80）的学生均可获得；
3) 成绩优秀奖，每人2000元，期末平均成绩高于90分（>90）的学生均可获得；
4) 西部奖学金，每人1000元，期末平均成绩高于85分（>85）的西部省份学生均可获得；
5) 班级贡献奖，每人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.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
String[] name = new String[n];
int[] avgs = new int[n];
int[] s = new int[n];
String[] ganbu = new String[n];
String[] xibu = new String[n];
byte[] lw = new byte[n];
int[] rmb = new int[n];
int max = 0;
int index = 0;
int sum = 0;
for (int i = 0; i < n; i++) {
name[i] = in.next();
avgs[i] = in.nextInt();
s[i] = in.nextInt();
ganbu[i] = in.next();
xibu[i] = in.next();
lw[i] = in.nextByte();
rmb[i] = money(avgs[i], s[i], ganbu[i], xibu[i], lw[i]);
if (max < rmb[i]) {
max = rmb[i];
index = i;
}
sum += rmb[i];
}
System.out.println(name[index]);
System.out.println(max);
System.out.println(sum);
}
public static int money(int avgs, int s, String ganbu, String xibu, byte lw) {
int rmb = 0;
if (avgs > 80 && lw >= 1) {
rmb += 8000;
}
if (avgs > 85 && s > 80) {
rmb += 4000;
}
if (avgs > 90) {
rmb += 2000;
}
if (avgs > 85 && "Y".equals(xibu)) {
rmb += 1000;
}
if (s > 80 && "Y".equals(ganbu)) {
rmb += 850;
}
return rmb;
}
}46:生日相同
描述
在一个有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.*;
import java.math.*;
public class Main
{
static String union(int month, int day)
{
String m = month+"";
String d = day+"";
if(month < 10)
m = "0" + m;
if(day < 10)
d = "0" + d;
return m + " " + d;
}
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int n = in.nextInt();
TreeMap<String,String> tm = new TreeMap<String, String>();
for(int i = 1; i <= n; i++)
{
String s = in.next();
int month = in.nextInt();
int day = in.nextInt();
String key = union(month,day);
String value = tm.get(key);
if(value == null)
tm.put(key,s);
else
tm.put(key, value + " " + s);
}
Set<String> node = tm.keySet();
for(String flag:node)
{
String tmp = tm.get(flag);
if(tmp.indexOf(" ") != -1)
{
String[] ans = flag.split(" ");
System.out.println(Integer.parseInt(ans[0])+ " " + Integer.parseInt(ans[1]) + " " + tmp);
}
}
}
}TreeMap特点：不允许出现重复的key； 可以插入null键，null值；
可以对元素进行排序； 无序集合（插入和遍历顺序不一致）
get(key)：根据指定的key值返回对应的value
map.put(key, value)：将指定的key, value对添加到map里
remove(key)：删除key值对应的entry
map.keySet():获取 map 集合的所有键，并存放在一个 Set 集合对象中
String.indexOf(substring, int m) ：搜索String中的substring, 默认从第m位开始
Integer.parseInt( )：把( )里的内容转换成整数（这里也有一点点的解释）
47:扩号匹配
描述
判断一组匹配的左右扩号序列中，每一个右扩号与之相匹配成对的左扩号是整个扩号序列的第几个扩号。输出所有判断结果。
输入
输入有两行。
第一行输入一个整数（该整数必定是偶数），该整数表示扩号序列中一共有多少个扩号。
第二行输入用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
import java.util.*;
public class Main
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
Stack<Integer> st=new Stack<>();//栈
while(in.hasNext()) {
int n = in.nextInt();
String s = in.next();
for(int i=0;i<n;i++) {
char c = s.charAt(i);
if(c=='1') {
st.push(i+1); //addfirst
}
else {
System.out.print(st.pop()+" ");
}
}
System.out.println();
}
}
}48:集合合并
描述
已知集合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
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int m = in.nextInt();
int n = in.nextInt();
Set<Integer> s = new LinkedHashSet<>();
for (int i = 0; i < m + n; i++) {
s.add(in.nextInt());
}
System.out.println(s.size());
for (Integer k : s) { //加强的for循环方式，在遍历数组或集合时常用
System.out.print(k + " ");
}
}
}49:字符串排序
描述
先输入你要输入的字符串的个数。然后换行输入该组字符串。每个字符串以回车结束，每个字符串少于一百个字符。如果在输入过程中输入的一个字符串为“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
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
in.nextLine();
List<String> list1 = new ArrayList<>();
for (int i = 0; i < n ; i++) {
String s = in.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);
}
}
}50:最远距离
描述
给定一组点(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
import java.util.*;
class Point {
double x, y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public double distance(Point p) {
return Math.sqrt((this.x - p.x) * (this.x - p.x) + (this.y - p.y) * (this.y - p.y)); //计算两点距离
}
}
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
Point[] p = new Point[n];
for (int i = 0; i < n; i++) {
p[i] = new Point(in.nextDouble(), in.nextDouble());
}
double maxd = 0;
for (int i = 0; i < n - 1; i++) {
for (int j = i + 1; j < n; j++) {
double dis = p[i].distance(p[j]);
if (dis > maxd) {
maxd = dis;
}
}
}
System.out.printf("%.4f\n", maxd);
}
}51:竞赛评分
描述
现举行一次小竞赛,参赛的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.*;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
Team[] t = new Team[3];
for (int i = 0; i < 3; i++) {
t[i] = new Team(i + 1, 0);
}
int n = in.nextInt();
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++) {
String st = in.next();
if (st.equals("right")) {
t[j].score += 10;
} else if (st.equals("wrong")) {
t[j].score -= 10;
}
}
}
Arrays.sort(t, (x, y) -> y.score - x.score);
System.out.print("(" + t[0].num + "," + t[0].score + ")");
for (int i = 1; i < 3; i++) {
if (t[i].score < t[i - 1].score) {
System.out.println();
}
System.out.print("(" + t[i].num + "," + t[i].score + ")");
}
}
}
class Team {
int num;
Integer score;
public Team(int no, Integer score) {
this.num = no;
this.score = score;
}
}包含浅浅的sort( )用法 
https://blog.csdn.net/qq_51308613/article/details/123464797?spm=1001.2014.3001.5502
52:验证“歌德巴赫猜想”
描述
验证“歌德巴赫猜想”，即：任意一个大于等于6的偶数均可表示成两个素数之和。
输入
输入只有一个正整数x。(x<=2000)
输出
如果x不是“大于等于6的偶数”，则输出一行：
Error!
否则输出这个数的所有分解形式，形式为：
x=y+z
其中x为待验证的数，y和z满足y+z=x，而且y<=z，y和z均是素数。
如果存在多组分解形式，则按照y的升序输出所有的分解，每行一个分解表达式。
注意输出不要有多余的空格。
样例输入
输入样例1: 7 输入样例2: 10 输入样例3: 100
样例输出
输出样例1: Error! 输出样例2: 10=3+7 10=5+5 输出样例3: 100=3+97 100=11+89 100=17+83 100=29+71 100=41+59 100=47+53
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int y,z;
int x = in.nextInt();
if(x<6||x%2!=0)
System.out.println("Error!");
for(y=3;y<=x/2;y+=2) //y在3到x/2之间且y一定不是偶数，同理z在x/2到x之间
{
z = x - y;
if(right(y)&&right(z))
{
System.out.println(x+"="+y+"+"+z);
}
}
}
public static boolean right(int i) { //判断是否为质数
for (int j = 2; j < i - 1; j++) {
if (i % j == 0) {
return false;
}
}
return true;
}
}
1467
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
