【Java】2021 RoboCom 机器人开发者大赛-高职组（复赛）题解
7-8 人工智能打招呼
号称具有人工智能的机器人，至少应该能分辨出新人和老朋友，所以打招呼的时候应该能有所区别。本题就请你为这个人工智能机器人实现这个功能：当它遇到陌生人的时候，会说：“Hello X, how are you?”其中 X 是这个人的称呼；而当它再次遇到这个人的时候，会说：“Hi X! Glad to see you again!”
输入格式：
输入首先在第一行中给出一个正整数 N（≤105），随后一行给出 N 个人的编号。即简单起见，我们把每个人的称呼 X 用一个 5 位整数来替代。
输出格式：
对于每个人的编号，按照题面要求在一行中输出人工智能机器人打招呼的内容。
输入样例：
7
00000 99999 00000 12345 00000 12345 00000
输出样例：
Hello 00000, how are you?
Hello 99999, how are you?
Hi 00000! Glad to see you again!
Hello 12345, how are you?
Hi 00000! Glad to see you again!
Hi 12345! Glad to see you again!
Hi 00000! Glad to see you again!
Solution：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(in.readLine());
String[] input = in.readLine().split(" ");
int[] book = new int[1000000];
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++) {
int x = Integer.parseInt(input[i]);
if (book[x] != 1) {
sb.append("Hello ").append(input[i]).append(", how are you?");
book[x] = 1;
} else {
sb.append("Hi ").append(input[i]).append("! Glad to see you again!");
}
if (i < n - 1) sb.append("\n");
}
System.out.println(sb);
}
}
7-9 人工智能数字翻译
千万不要以为地球上的人类都用十进制数字。事实上，地球上不同国家、不同民族在用的数字系统多达十几套。例如新几内亚的 Oksapmin 人用的是 27 进制的数字系统，如上图所示，他们用身体的 27 个部位表示 27 个数字。例如他们管 1 叫“提普纳”，即一只手的大拇指；管 6 叫“都怕”，是指手腕；管 12 叫“纳塔”，指耳朵，等等。于是他们那里的 10 是十进制系统里的 27，20 是十进制里的 54 …… 当两个不同数字系统的人类碰到一起谈价钱，大家就很头痛了，于是搞了一个人工智能数字翻译，可以把数字从一个系统翻译到另一个系统。本题就请你来实现这个人工智能数字翻译功能。
输入格式：
输入在第一行中给出两个非负整数：A（≤108 —— 这里 108 是十进制数）和 D，其中 A 是 10 或 27 进制数，D 是 A 的进制，或者是 10，或者是 27。如果 A 是 27 进制数，我们用 0 - 9 表示前 10 个数，用 A - Q 表示后面 17 个数。
输出格式：
在一行中将输入的数字翻译成另一个进制系统的数字。
输入样例 1：
6397636 10
输出样例 1：
C10OD
输入样例 2：
8E0A 27
输出样例 2：
167680
Solution：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String[] input = in.readLine().split(" ");
int D = Integer.parseInt(input[1]);
if (D == 10) {
System.out.println(Integer.toString(Integer.parseInt(input[0]), 27).toUpperCase());
} else {
System.out.println(Integer.parseInt(input[0], 27));
}
}
}
7-10 机器人拼图
给定一块由 n×m 个格子组成的矩形拼图板，本题要求你根据给定的机械手移动指令集，将拼图中的碎片逐一放到指定位置。
机械手每次抓取一块碎片，都会在拼图板的左上角位置等待指令。一个指令集是由 0-4 这五个数字组成的字符串，每个数字代表的意义如下：
- 1：向右移动一格；
- 2：向下移动一格；
- 3：向左移动一格；
- 4：向上移动一格；
- 0：将碎片放置在当前位置，并结束这次任务。
如果指令要求机械手移动到拼图板边界外，机械手会无视这个指令。如果接收到指令 0 时，当前位置上已经有一块碎片放好了，机械手会扔掉手里的碎片，结束这次任务。
输入格式：
输入第一行给出 2 个正整数 n 和 m（1≤n,m≤100），随后一共有 n×m 行，第 i 行给出编号为 i（i=1,⋯nm）的碎片对应的指令集，每条指令集一定以唯一的 0 结尾。
输出格式：
输出 n 行，每行 m 个整数，为放置在对应位置上的碎片编号。如果该位置上没有碎片，则输出 0。一行中的数字间以 1 个空格分隔，行首位不得有多余空格。
输入样例：
2 3
1120
21140
34120
0
110
21111340
输出样例：
4 6 2
0 3 1
Solution：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String[] input = in.readLine().split(" ");
int n = Integer.parseInt(input[0]);
int m = Integer.parseInt(input[1]);
int row = n * m;
int[][] map = new int[n + 1][m + 1];
for (int i = 1; i <= row; i++) {
char[] c = in.readLine().toCharArray();
int x = 1, y = 1;
for (int j = 0; j < c.length; j++) {
int op = c[j] - '0';
if (op == 1 && y != m) {
y++;
} else if (op == 2 && x != n) {
x++;
} else if (op == 3 && y != 1) {
y--;
} else if (op == 4 && x != 1) {
x--;
}
}
if (map[x][y] == 0) {
map[x][y] = i;
}
}
StringBuilder sb = new StringBuilder();
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < m + 1; j++) {
sb.append(map[i][j]);
if (j < m) sb.append(" ");
}
if (i < n) sb.append("\n");
}
System.out.println(sb);
}
}
7-11 PAT 基础级排名
PAT 的段位分为 9 个级别，其中基础级考试分为青铜、白银、黄金、白金、钻石这 5 个段位，满分分别为 30、50、60、80、100。
基础级考试由报考单位订制需要的最高级别，设为级别 L，根据考生获得的分数所在的分数段决定该生获得的证书级别和证书内容，规则为：
- 若考生的分数超过段位 L1 的满分，且不高于段位 L2 的满分，并且 L1 和 L2 为相邻段位，则该生获得 L2 段位的证书；
- 证书上包含两个成绩：S/F 和 R/T，其中 S 是本人得分；F 是该段位满分；R 是本人在该段位证书获得者中的排名；T 是位于该段位及以下段位考生总人数。
给定一组考生的成绩，请你编写程序生成他们的证书。
输入格式：
输入首先在第一行给出 2 个正整数：一个是不超过 1000 的正整数 N，为考生总人数；另一个是单位订制的最高段位级别 L，在 [1, 5] 区间内，依次对应青铜、白银、黄金、白金、钻石这 5 个段位。
随后 N 行，每行给出一位考生的准考证号和成绩，其间以空格分隔。准考证号为长度不超过 10 的、由数字和英文字母组成的字符串；成绩为不超过段位 L 的满分的非负整数。
输出格式：
按照成绩从高到低的顺序输出每位考生的证书信息，格式为：
准考证号 段位 S/F R/T
成绩并列的考生拥有并列的排名，其后的考生名次按实际位次计算。例如有 5 位考生得到满分 100 时，他们都是第 1 名，而考 99 的考生就是第 6 名。成绩并列的考生按准考证号的字典序递增输出。题目保证准考证号没有重复。
注意：零分没有证书。对于零分的考生，只按字典序递增输出其准考证号。
输入样例：
10 4
CN001 58
CN012 49
CN233 0
CN003 0
CN025 31
CN999 80
CN666 80
CN777 60
CN007 79
CN250 15
输出样例：
CN666 4 80/80 1/10
CN999 4 80/80 1/10
CN007 4 79/80 3/10
CN777 3 60/60 1/7
CN001 3 58/60 2/7
CN012 2 49/50 1/5
CN025 2 31/50 2/5
CN250 1 15/30 1/3
CN003
CN233
Solution：
::: danger
测试点 1、4 答案错误
:::
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String[] input = in.readLine().split(" ");
int n = Integer.parseInt(input[0]);
int l = Integer.parseInt(input[1]);
List<Rank> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
input = in.readLine().split(" ");
int score = Integer.parseInt(input[1]);
int L = 0;
if (score <= 30) list.add(new Rank(input[0], 1, score, 30));
else if (score <= 50) list.add(new Rank(input[0], 2, score, 50));
else if (score <= 60) list.add(new Rank(input[0], 3, score, 60));
else if (score <= 80) list.add(new Rank(input[0], 4, score, 80));
else if (score <= 100) list.add(new Rank(input[0], 5, score, 100));
}
list.sort(null);
int index = 1, cnt = 0, t = 0;
Rank temp = list.get(0);
StringBuilder sb = new StringBuilder();
int size = list.size();
for (int i = 0; i < size; i++) {
Rank rank = list.get(i);
if (rank.score == 0) {
sb.append(rank.num);
} else {
sb.append(rank.num).append(" ").append(rank.L).append(" ").append(rank.score).append("/")
.append(rank.fullScore).append(" ");
if (temp.score == rank.score && temp.L == rank.L) {
sb.append(index).append("/").append(n);
t++;
} else if (temp.score != rank.score && temp.L == rank.L) {
index = t + 1;
sb.append(index).append("/").append(n);
t++;
} else {
temp = list.get(i);
index = 1;
n -= t;
sb.append(index).append("/").append(n);
t = 1;
}
}
cnt++;
if (i < size - 1) sb.append("\n");
}
System.out.println(sb);
}
}
class Rank implements Comparable<Rank> {
String num;
int L;
int score;
int fullScore;
public Rank(String num, int l, int score, int fullScore) {
this.num = num;
L = l;
this.score = score;
this.fullScore = fullScore;
}
@Override
public int compareTo(Rank o) {
int r = o.score - this.score;
if (r == 0) r = this.num.compareTo(o.num);
return r;
}
}
7-12 人工智能刑警
人工智能技术在刑侦领域已经有了长足的发展，可以在拥挤的人群中识别出每个人的面部特征，与数据库中所有罪犯的面部特征进行匹配，自动识别出其中的罪犯。
本题就请你实现一个简单的自动识别程序，根据系统抽取出的若干面部特征判断其是否罪犯。
输入格式：
输入第一行给出两个正整数 N（≤2×104）和 M（≤10），分别为数据库中罪犯的数量和每个人脸提取的不同特征的数量。随后 N 行，每行给出 M 个整数，以空格分隔。第 i 行给出的是第 i 号罪犯的面部特征（1≤i≤N），格式为：
特征1 特征2 …… 特征M ID
其中每个特征是一个 [1,109] 区间内的整数；ID 是罪犯的编号，为不超过 20 位的正整数。注意不同位置的特征对应不同种类，例如特征1对应眼距、特征2对应唇宽等等。题目保证不存在任何两个罪犯具有完全相同的面部特征，所有 ID 也都是不同的。
再下面给出一系列捕捉到的人脸的面部特征。当特征1为 0 时标志输入结束，这一行输入不要处理。此外，为了帮助你区分罪犯和普通人的数据，这两部分数据之间有一个空行。（因为是简单题，所以查询数据量比较小，不超过 2000。当然你可以考虑一下，如果查询数量巨大应该怎么处理……）
输出格式：
对每个捕捉到的人脸，如果与某个罪犯完全匹配，则在一行中输出罪犯编号（注意：如果有前导零也必须原样输出）；如果没有匹配任何罪犯，则输出 Pass。
输入样例：
9 4
15 23 23 7 0001
12 32 15 5 2001
10 15 23 3 3725
12 17 15 6 0238
15 10 23 11 99674
29 32 33 4 00253
9 31 987 13 1004
29 32 15 12 8791
15 23 25 7 7720
15 23 23 7
12 17 15 6
10 15 15 3
29 32 33 4
15 32 12 29
9 31 987 13
5 10 23 1
0 0 0 0
输出样例：
0001
0238
Pass
00253
Pass
1004
Pass
Solution：
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
String[] input = in.readLine().split(" ");
int n = Integer.parseInt(input[0]);
int m = Integer.parseInt(input[1]);
Map<String, String> map = new HashMap<>();
for (int i = 0; i < n; i++) {
input = in.readLine().split(" ");
StringBuilder sb = new StringBuilder();
for (int j = 0; j < m; j++) {
sb.append(input[j]);
if (j < m - 1) sb.append(" ");
}
map.put(sb.toString(), input[m]);
}
in.readLine();
input = in.readLine().split(" ");
while (!input[0].equals("0")) {
StringBuilder sb = new StringBuilder();
for (int j = 0; j < m; j++) {
sb.append(input[j]);
if (j < m - 1) sb.append(" ");
}
System.out.println(map.getOrDefault(sb.toString(), "Pass"));
input = in.readLine().split(" ");
}
}
}