题目来源：https://pintia.cn/market/item/1767454903977603072
B-1
题目要求
2024 这个数字，可以由 n n n个互不相同的正偶数和 m m m个互不相同的正奇数组合出来吗？本题就请你回答这个问题。
输入格式：
输入在一行中给出一个正整数 K ( K ≤ 10 ) K(K\le 10) K(K≤10)。随后 K K K行，每行给出一对 n n n和 m m m，均不超过 1000。
输出格式：
对每一对输入，如果可以由
n
n
n个互不相同的正偶数和
m
m
m个互不相同的正奇数相加得到 2024，则在一行中输出 <font style="color:rgb(231, 76, 60);">yes</font>，否则输出 <font style="color:rgb(231, 76, 60);">no</font>。
输入样例：
5
57 2
32 30
25 13
19 26
38 40
输出样例：
no
yes
no
yes
no
解题思路
给定 n n n和 m m m，让我们判断能不能由 n n n个不同的正偶数和 m m m个不同的正奇数组成2024。
正难则反，我们考虑什么情况下不能组成2024。
先从奇偶性判断， n n n个正偶数一定是正偶数，所以要组成2024（偶数）， m m m个奇数一定也得是偶数，所以 m m m一定要为偶数。
再从大小判断， n n n个不同的正偶数组成的数最小是 ( 2 + 2 ∗ n ) ∗ n / 2 = ( 1 + n ) ∗ n 2 (2+2*n)*n/2=(1+n)*n^2 (2+2∗n)∗n/2=(1+n)∗n2， m m m个奇数组成的最小的数是 ( 1 + 2 ∗ m − 1 ) ∗ m / 2 = m 2 (1+2*m-1)*m/2=m^2 (1+2∗m−1)∗m/2=m2，所以 ( 1 + n ) ∗ n 2 + m 2 ≤ 2024 (1+n)*n^2+m^2\le 2024 (1+n)∗n2+m2≤2024
满分代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int K = scanner.nextInt();
int m = 0;
int n = 0;
int s1 = 0;
int s2 = 0;
while (K-- > 0) {
m = scanner.nextInt();
n = scanner.nextInt();
if (n % 2 != 0) {
if(K==0){
System.out.print("no");
}else {
System.out.println("no");
}
continue;
}
// s1=(2+m*2)*m/2;
s1=(1+m)*m;
// s2=(1+n*2-1)*n/2;
s2=n*n;
if (s1 + s2 <= 2024) {
if(K==0){
System.out.print("yes");
}else {
System.out.println("yes");
}
}else{
if(K==0){
System.out.print("no");
}else {
System.out.println("no");
}
}
}
}
}
B-2
题目要求
判断一个正整数 N N N除以 99 的余数 r r r时，可以把这个数从右向左每 2 位数断开成一个数字，得到的数字求和，再除以 99，得到的余数一定还是 r r r。例如 12345 % 99 = (1+23+45) % 99 = 69。但如果你从左向右断开就会出错，例如 (12+34+5)%99 = 51 就得不到正确答案了。然而有这么一些数字，两个方向断开计算的结果正好是一样的，比如偶数位的所有数字…… 那么奇数位的数字有没有双向断开都正确的呢？答案是：有。我们给这种“双向断开都正确”的数字取名为“真爱 99”数。本题就请你判断一个给定的数字是否真爱 99。
输入格式：
输入第一行给出 1 个正整数 n ( 3 ≤ n ≤ 100 ) n(3\le n\le 100) n(3≤n≤100)，随后 n n n行，每行给出一个需要判断的正整数 N ( ≤ 10 1000 ) N(\le {10}^{1000}) N(≤101000)。题目保证输入的数字没有多余的前导零。
输出格式：
对每个需要判断的数字，如果它是真爱 99，就在一行中输出 <font style="color:rgb(231, 76, 60);">yes</font>，否则输出 <font style="color:rgb(231, 76, 60);">no</font>。
输入样例：
5
12345
54123
1234
90217352811402416
187438345730263655307266542930923
输出样例：
no
yes
yes
yes
no
满分代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = Integer.parseInt(scanner.nextLine());
String str = "";
int leftToRight = 0;
int rightToLeft = 0;
while (n-- > 0) {
str = scanner.nextLine();
if (str.length() % 2 == 0) {
System.out.println("yes");
continue;
}
leftToRight = 0;
rightToLeft = 0;
for (int i = 0; i < str.length() - 1; i=i+2) {
leftToRight = (leftToRight + Integer.parseInt(str.substring(i,i+2)))%99;
}
leftToRight=(leftToRight+Integer.parseInt(str.substring(str.length()-1)))%99;
for (int i = str.length() - 1; i >=1 ; i=i-2) {
rightToLeft = (rightToLeft + Integer.parseInt(str.substring(i-1,i+1)))%99;
}
rightToLeft =(rightToLeft + Integer.parseInt(str.substring(0,1)))%99;
if (leftToRight==rightToLeft){
System.out.println("yes");
}else {
System.out.println("no");
}
}
}
}
B-3
给定
n
n
n个单词，如果我们将每个单词存在一个数组里，所有数组的长度都取同一个固定值，则最少要耗费多少存储空间？这里假设 ASCII 码中，一个英文字母占一个字节的空间。例如对 2 个单词 <font style="color:rgb(231, 76, 60);">pat</font> 和 <font style="color:rgb(231, 76, 60);">test</font>，我们需要长度为 4 的数组存 <font style="color:rgb(231, 76, 60);">pat</font>，长度为 5 的数组存 <font style="color:rgb(231, 76, 60);">test</font> —— 这里假设用 C 语言的存储方式，字符串末尾的结束符也占一个字节 —— 则两者都可用的数组长度就是 5。
输入格式：
输入第一行首先给出一个正整数 n ( ≤ 1 0 5 ) n(\le 10^5) n(≤105)，是单词的数量。随后 n n n行，每行给出一个单词，为仅由小写英文字母组成的非空字符串，以回车结尾。
输出格式：
在一行中，首先输出存储单词的定长字符串的长度（注意字符串结束符也占一个字节），然后输出存储这些单词一共需要多少空间，以字节为单位。两个数字间以 1 个空格分隔，行首尾不得有多余空格。
题目保证输出的数字不会超过
1
0
8
10^8
108。
输入样例：
5
programming
contest
internationalization
pneumonoultramicroscopicsilicovolcanoconiosis
hippopotomonstrosesquippedaliophobia
输出样例：
46 230
解题思路
其实就是找到最长的字符串，那么我们需要的数组长度就为最长的字符串长度+1(回车符)。
满分代码
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = Integer.parseInt(scanner.nextLine());
int m = n;
int max = 0;
while (n-- > 0) {
max = Math.max(max, scanner.nextLine().length());
}
max++;
System.out.print(max);
System.out.print(" ");
System.out.println(m*max);
}
}
B-4
给定一张纸，你需要识别上面的盲文数字。
盲文一般由一个三行两列的凸出或不凸出的点表示，我们以<font style="color:rgb(231, 76, 60);">*</font>表示凸出，<font style="color:rgb(231, 76, 60);">.</font>表示不凸出。盲文的数字表达一般有两种形式，其中布莱叶式如下所示：
为方便解题，以下是文字版：
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 |
|---|---|---|---|---|---|---|---|---|---|
| *. … … | . . … | ** … … | ** .* … | . . … | ** *. … | ** ** … | *. ** … | .* *. … | .* ** … |
纸以 N × M N\times M N×M的格子给出，请统计纸上每种盲文数字分别有多少个。
题目要求
输入格式:
输入第一行是两个正整数。
接下来的
N
N
N行，每行
M
M
M个字符，表示纸上的符号。字符只会是 <font style="color:rgb(231, 76, 60);">*</font> 或 <font style="color:rgb(231, 76, 60);">.</font>。
数据可能存在因重叠而导致的重复计算情况，如下：
****
....
....
对于这种情况，你应该计算为 3 个 “3”。
输出格式:
输出一行 10 个数，分别是盲文的 1、2、3、4、5、6、7、8、9、0 在纸上有多少个。数字间以 1 个空格分隔，行首尾不得有多余空格。
输入样例:
7 10
..........
.*..**....
..........
..........
.***......
..*.......
..........
输出样例:
3 0 1 1 0 1 0 0 0 0
解题思路
我对每个数字(0-9)进行了唯一的数值定义，使得每个数字与数值有了一对一的关系，对应代码如下：
HashMap<Integer, Integer> map = new HashMap<>();
map.put(1, 1);
map.put(101, 2);
map.put(11, 3);
map.put(1011, 4);
map.put(1001, 5);
map.put(111, 6);
map.put(1111, 7);
map.put(1101, 8);
map.put(110, 9);
map.put(1110, 0);
满分代码
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
HashMap<Integer, Integer> map = new HashMap<>();
// map.put(1, 1);
// map.put(2, 101);
// map.put(3, 11);
// map.put(4, 1011);
// map.put(5, 1001);
// map.put(6, 111);
// map.put(7, 1111);
// map.put(8, 1101);
// map.put(9, 110);
// map.put(0, 1110);
map.put(1, 1);
map.put(101, 2);
map.put(11, 3);
map.put(1011, 4);
map.put(1001, 5);
map.put(111, 6);
map.put(1111, 7);
map.put(1101, 8);
map.put(110, 9);
map.put(1110, 0);
Scanner scanner = new Scanner(System.in);
String[] s = scanner.nextLine().split(" ");
int[] answer = new int[10];
int N = Integer.parseInt(s[0]);
int M = Integer.parseInt(s[1]);
ArrayList<String> list = new ArrayList<>();
for (int i = 0; i < N; i++) {
list.add(scanner.nextLine());
}
int temp = 0;
for (int i = 0; i < N - 2; i++) {
for (int j = 0; j < M - 1; j++) {
temp = 0;
if (list.get(i).charAt(j) == '*') {
temp = temp + 1;
}
if (list.get(i).charAt(j + 1) == '*') {
temp = temp + 10;
}
if (list.get(i + 1).charAt(j) == '*') {
temp = temp + 100;
}
if (list.get(i + 1).charAt(j + 1) == '*') {
temp = temp + 1000;
}
if (list.get(i + 2).charAt(j) == '*') {
temp = temp + 10000;
}
if (list.get(i + 2).charAt(j + 1) == '*') {
temp = temp + 100000;
}
if (map.containsKey(temp)) {
answer[map.get(temp)]++;
}
}
}
for (int i = 1; i < answer.length; i++) {
System.out.print(answer[i]+" ");
}
System.out.println(answer[0]);
}
}
B-5
题目要求
在攀拓考试的能力评估报告中，需要用 AI（人工智能）算法，根据考生的表现自动生成一段评语。本题并不是要求你写出生成评语用的代码，只是要求你准备好调用这个算法的输入数据。
首先，已经有算法为每位考生计算出了 5 个维度的能力评估值，分别是：基础知识、进阶知识、熟练度、准确性、专业性。我们不妨将这些维度从 1 到 5 顺次编号。每个能力评估值都是 [0, 100] 区间内的整数。你先要获得每一个维度上所有
N
N
N位考生的中位线值 —— 如果
N
N
N是奇数，那么中位线是从大到小第
(
N
+
1
)
/
2
(N+1)/2
(N+1)/2个值；如果
N
N
N是偶数，那么中位线是从大到小第
N
/
2
N/2
N/2个值。随后对每位考生，比较其能力评估值
(
v
1
,
v
2
,
⋯
,
v
5
)
(v_1,v_2,\cdots,v_5)
(v1,v2,⋯,v5)与对应的中位线值
(
m
1
,
m
2
,
⋯
,
m
5
)
(m_1,m_2,\cdots,m_5)
(m1,m2,⋯,m5)。如果
v
i
≥
m
i
v_i\ge m_i
vi≥mi，则将第
i
i
i个维度记入正向反馈类，否则记入负向反馈类。
输入格式：
输入首先在第一行给出两个正整数 N N N和 M M M ( 1 ≤ M ≤ N ≤ 1 0 5 ) (1\le M\le N\le 10^5) (1≤M≤N≤105)，分别是考生总人数和需要查询的考生人数。随后 N N N行，每行给出一位考生的信息，格式为：
准考证号 v1 v2 v3 v4 v5
其中<font style="color:rgb(231, 76, 60);">准考证号</font>是长度不超过 12 的、由英文字母和数字组成的字符串，后面跟的 5 个数值是该考生的 5 个维度的能力评估值。
最后是
M
M
M行，每行给出一个需要查询的<font style="color:rgb(231, 76, 60);">准考证号</font>。
输出格式：
对每个需要查询的<font style="color:rgb(231, 76, 60);">准考证号</font>，在一行中输出其正向和负向反馈类的信息，格式为：首先按
v
i
−
m
i
v_i-m_i
vi−mi的数值非递增顺序输出正向反馈类中维度的编号，然后按
m
i
−
v
i
m_i-v_i
mi−vi的数值非递减顺序输出负向反馈类中维度的编号，但这个编号前要加负号 <font style="color:rgb(231, 76, 60);">-</font>。如果同类中差值有并列，则按维度编号递增序输出。
所有 5 个维度编号输出在一行，其间以 1 个空格分隔。行首尾不得有多余空格。
如果查询的准考证号不存在，则在对应一行中输出 <font style="color:rgb(231, 76, 60);">Not Found</font>。
输入样例：
5 3
A20190289 98 74 35 88 60
B20018372 86 86 86 72 60
A19873001 62 48 55 20 35
T27346900 76 54 68 81 70
B00247834 92 68 78 50 66
T27346900
F19993001
B20018372
输出样例：
5 4 3 -1 -2
Not Found
2 3 1 4 5
解题代码
没什么简化思路，纯粹暴力解，可惜部分超时了。
import java.util.ArrayList;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String line = scanner.nextLine();
String[] split = line.split(" ");
int N = Integer.parseInt(split[0]);
int M = Integer.parseInt(split[1]);
int level1 = 0;
int level2 = 0;
int level3 = 0;
int level4 = 0;
int level5 = 0;
LinkedList<Integer> level1_list = new LinkedList<>();
LinkedList<Integer> level2_list = new LinkedList<>();
LinkedList<Integer> level3_list = new LinkedList<>();
LinkedList<Integer> level4_list = new LinkedList<>();
LinkedList<Integer> level5_list = new LinkedList<>();
LinkedList<Student> students = new LinkedList<>();
int k=0;
while (k++<N) {
String[] str = scanner.nextLine().split(" ");
level1 = Integer.parseInt(str[1]);
level2 = Integer.parseInt(str[2]);
level3 = Integer.parseInt(str[3]);
level4 = Integer.parseInt(str[4]);
level5 = Integer.parseInt(str[5]);
level1_list.add(level1);
level2_list.add(level2);
level3_list.add(level3);
level4_list.add(level4);
level5_list.add(level5);
students.add(new Student(str[0], level1, level2, level3, level4, level5));
}
level1_list.sort((o1, o2) -> o2 - o1);
level2_list.sort((o1, o2) -> o2 - o1);
level3_list.sort((o1, o2) -> o2 - o1);
level4_list.sort((o1, o2) -> o2 - o1);
level5_list.sort((o1, o2) -> o2 - o1);
int level1_med = 0;
int level2_med = 0;
int level3_med = 0;
int level4_med = 0;
int level5_med = 0;
if (N % 2 == 0) {
level1_med = level1_list.get(N / 2-1);
level2_med = level2_list.get(N / 2-1);
level3_med = level3_list.get(N / 2-1);
level4_med = level4_list.get(N / 2-1);
level5_med = level5_list.get(N / 2-1);
} else {
level1_med = level1_list.get((N + 1) / 2-1);
level2_med = level2_list.get((N + 1) / 2-1);
level3_med = level3_list.get((N + 1) / 2-1);
level4_med = level4_list.get((N + 1) / 2-1);
level5_med = level5_list.get((N + 1) / 2-1);
}
int flag = -1;
int x = 0;
while (x++ < M) {
line = scanner.nextLine();
flag = -1;
for (int i = 0; i < students.size(); i++) {
// System.out.println(line);
// System.out.println(students.get(i).id);
if (students.get(i).id.equals(line)) {
flag = i;
break;
}
}
if (flag == -1) {
System.out.println("Not Found");
continue;
}
ArrayList<Cha> cha = new ArrayList<>();
// for (int i = 0; i < students.size(); i++) {
// students.get(i).level1_cha=level1-level1_med;
// students.get(i).level2_cha=level2-level2_med;
// students.get(i).level3_cha=level3-level3_med;
// students.get(i).level4_cha=level4-level4_med;
// students.get(i).level5_cha=level5-level5_med;
cha.add(new Cha(students.get(flag).level1 - level1_med, 1));
cha.add(new Cha(students.get(flag).level2 - level2_med, 2));
cha.add(new Cha(students.get(flag).level3 - level3_med, 3));
cha.add(new Cha(students.get(flag).level4 - level4_med, 4));
cha.add(new Cha(students.get(flag).level5 - level5_med, 5));
cha.sort(new Comparator<Cha>() {
@Override
public int compare(Cha o1, Cha o2) {
return o2.cha-o1.cha;
}
});
for (int i = 0; i < cha.size(); i++) {
if (cha.get(i).cha<0){
System.out.print("-");
}
if (i==cha.size()-1){
System.out.print(cha.get(i).id);
}else {
System.out.print(cha.get(i).id+" ");
}
}
System.out.println();
}
}
}
//}
class Student {
String id;
int level1;
int level2;
int level3;
int level4;
int level5;
int level1_cha;
int level2_cha;
int level3_cha;
int level4_cha;
int level5_cha;
public Student() {
}
public Student(String id, int level1, int level2, int level3, int level4, int level5) {
this.id = id;
this.level1 = level1;
this.level2 = level2;
this.level3 = level3;
this.level4 = level4;
this.level5 = level5;
}
}
class Cha {
int cha;
int id;
public Cha(int cha, int id) {
this.cha = cha;
this.id = id;
}
}
参考资料
https://mp.weixin.qq.com/s/Jqog451vSObXJf7Y1W7SlA
