第1题：小白鼠再排队
N只小白鼠(1 < N < 100)，每只鼠头上戴着一顶有颜色的帽子。现在称出每只白鼠的重量，要求按照白鼠重量从小到大的顺序输出它们头上帽子的颜色。帽子的颜色用 “red”，“blue”等字符串来表示。不同的小白鼠可以戴相同颜色的帽子。白鼠的重量用整数表示。
时间限制：1000
内存限制：65536
输入
输入第一行为一个整数N，表示小白鼠的数目。 下面有N行，每行是一只白鼠的信息。第一个为正整数，表示白鼠的重量，不超过整型范围;第二个为字符串，表示白鼠的帽子颜色，字符串长度不超过10个字符。 注意：白鼠的重量各不相同。
输出
按照白鼠的重量从小到大的顺序输出白鼠的帽子颜色。
样例输入
3
30 red
50 blue
40 green
样例输出
red
green
blue
以下是解决该问题的C语言代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
int weight;
char color[11];
} Mouse;
int compare(const void* a, const void* b) {
Mouse* mouseA = (Mouse*)a;
Mouse* mouseB = (Mouse*)b;
return mouseA->weight - mouseB->weight;
}
int main() {
int N;
scanf("%d", &N);
Mouse* mice = (Mouse*)malloc(N * sizeof(Mouse));
for (int i = 0; i < N; i++) {
scanf("%d %s", &mice[i].weight, mice[i].color);
}
qsort(mice, N, sizeof(Mouse), compare);
for (int i = 0; i < N; i++) {
printf("%s\n", mice[i].color);
}
free(mice);
return 0;
}
你可以将上述代码保存为一个名为 “mouse_sort.c” 的文件，并使用C编译器进行编译和运行。在输入小白鼠的数目和每只白鼠的信息后，程序将按照白鼠的重量从小到大的顺序输出白鼠的帽子颜色。
代码中使用了一个结构体 Mouse 来表示每只小白鼠的信息，包括重量和帽子颜色。compare 函数用于作为 qsort 函数的比较函数，以便按照白鼠的重量进行排序。
在主函数中，我们首先读取小白鼠的数目 N，然后动态分配一个大小为 N 的 Mouse 数组。接下来，我们使用循环逐个读取每只小白鼠的信息，并将其保存在数组中。然后，我们使用 qsort 函数对数组进行排序，排序的依据是比较函数 compare。最后，我们使用循环按顺序输出排序后的小白鼠的帽子颜色。
请注意，这个解决方案假设输入是有效的，并且满足题目要求。如果输入超出限制范围或包含非法字符，可能会导致输出错误。
第2题：多余的数
小A同学在完成一个数学题：求给定的10个整数的和。小A同学在求完之后发现和参考答案对不上，检查后发现在求和过程中多计算了一个数，其他过程没有问题。现给出小A计算用的11个数，以及正确的参考答案，请算出小A同学多计算的那一个数。
时间限制：1000
内存限制：65536
输入
第一行11个正整数，每个数小于等于1000000 第二行一个整数，表示参考答案
输出
一个整数，表示多计算的那一个数。
样例输入
2 4 6 8 1 3 5 7 9 5 11
54
样例输出
7
提示
样例中原有的10个数为2 4 6 8 1 3 5 9 5 11，和为54，多余的数为7。
以下是解决该问题的C语言代码：
#include <stdio.h>
int main() {
int nums[11];
int reference;
int sum = 0;
for (int i = 0; i < 11; i++) {
scanf("%d", &nums[i]);
sum += nums[i];
}
scanf("%d", &reference);
int extraNum = sum - reference;
printf("%d\n", extraNum);
return 0;
}
你可以将上述代码保存为一个名为 “extra_number.c” 的文件，并使用C编译器进行编译和运行。在输入11个正整数和参考答案后，程序将计算出小A同学多计算的那个数并输出。
在主函数中，我们首先定义一个整型数组 nums 用于存储11个正整数，以及一个整数变量 reference 用于存储参考答案。然后，我们使用循环逐个读取这11个数，并将它们累加到变量 sum 中。接下来，我们读取参考答案。根据题目描述，多计算的那个数等于总和减去参考答案，因此我们计算出 extraNum。最后，我们输出 extraNum。
请注意，这个解决方案假设输入是有效的，并且满足题目要求。如果输入超出限制范围，可能会导致输出错误。
第3题：打字员
有一个打字员,他打字的时候有个习惯,从来不用 Shift 来切换大小写,只用 Caps Lock。 现在给他一个地铁站的名字,你需要写一个程序来告诉他,他需要敲击多少下键盘才能打出 这个地铁站名。
时间限制：1000
内存限制：65536
输入
第一行输入一个数字 n (n<1000),表示共有多少个需要处理的车站名。从第 2 到第 n+1 行是这 n 个车站名。车站名由英文字母构成,名字的长度不会超过 100 个字符。已知开始时 键盘是输入小写字母的状态。
输出
这个打字员敲击键盘的次数。
样例输入
5
BeiJingDaXueDongMen
AAAaaaBBBbbbABAB
AmericanRAILWAY
AaAaAa
DFjfkdaB
样例输出
31
21
18
12
11
以下是解决该问题的C语言代码：
#include <stdio.h>
#include <string.h>
int main() {
int n;
scanf("%d", &n);
char station[101];
for (int i = 0; i < n; i++) {
scanf("%s", station);
int len = strlen(station);
int count = 0;
int capsLock = 0;
for (int j = 0; j < len; j++) {
if (station[j] >= 'A' && station[j] <= 'Z') {
if (!capsLock) {
capsLock = 1;
count++;
}
} else {
if (capsLock) {
capsLock = 0;
count++;
}
}
count++;
}
printf("%d\n", count);
}
return 0;
}
你可以将上述代码保存为一个名为 “typist.c” 的文件，并使用C编译器进行编译和运行。在输入车站名的数量以及每个车站名后，程序将计算出打字员敲击键盘的次数并输出。
在主函数中，我们首先读取车站名的数量 n。然后，使用循环逐个读取每个车站名，并进行处理。对于每个车站名，我们首先获取其长度 len，然后定义一个计数变量 count 和一个表示 Caps Lock 是否开启的标志变量 capsLock，初始状态下 capsLock 为 0。
接下来，我们使用另一个循环遍历车站名的每个字符。如果字符是大写字母，且 capsLock 为 0（表示当前是小写状态），则表示需要切换到大写状态，此时将 capsLock 设为 1，并将计数 count 加1。如果字符是小写字母，且 capsLock 为 1（表示当前是大写状态），则表示需要切换到小写状态，此时将 capsLock 设为 0，并将计数 count 加1。无论字符是大写字母还是小写字母，每遇到一个字符，计数 count 都需要加1。
最后，我们输出计数 count。
请注意，这个解决方案假设输入是有效的，并且满足题目要求。如果输入超出限制范围，可能会导致输出错误。
第4题：最好的草
奶牛Bessie计划好好享受柔软的春季新草。新草分布在R行C列的牧场里。它想计算一下牧场中的草丛数量。
在牧场地图中，每个草丛要么是单个“#”，要么是有公共边的相邻两个“#”。给定牧场地图，计算有多少个草丛。
例如，考虑如下5行6列的牧场地图
. # . . . .
. . # . . .
. . # . . #
. . . # # .
. # . . . .
这个牧场有5个草丛：一个在第一行，一个在第二列横跨了二、三行，一个在第三行，一个在第四行横跨了四、五列，最后一个在第五行。
时间限制：10000
内存限制：65536
输入
第一行包含两个整数R和C，中间用单个空格隔开。 接下来R行，每行C个字符，描述牧场地图。字符只有“#”或“.”两种。(1 <= R, C <= 100 )
输出
输出一个整数，表示草丛数。
样例输入
5 6
.#…
…#…
…#…#
…##.
.#…
样例输出
5
以下是解决该问题的C语言代码：
#include <stdio.h>
#define MAX_ROWS 100
#define MAX_COLS 100
int countGrasslands(char field[MAX_ROWS][MAX_COLS], int rows, int cols) {
int count = 0;
int visited[MAX_ROWS][MAX_COLS] = {0};
// 遍历牧场地图
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
// 如果当前位置是草丛且未被访问过
if (field[i][j] == '#' && !visited[i][j]) {
count++; // 增加草丛计数
visited[i][j] = 1; // 标记当前位置为已访问
// 标记与当前位置相邻的草丛为已访问
// 向右搜索
int k = j + 1;
while (k < cols && field[i][k] == '#') {
visited[i][k] = 1;
k++;
}
// 向下搜索
k = i + 1;
while (k < rows && field[k][j] == '#') {
visited[k][j] = 1;
k++;
}
}
}
}
return count;
}
int main() {
int rows, cols;
scanf("%d %d", &rows, &cols);
char field[MAX_ROWS][MAX_COLS];
// 读取牧场地图
for (int i = 0; i < rows; i++) {
scanf("%s", field[i]);
}
int result = countGrasslands(field, rows, cols);
printf("%d\n", result);
return 0;
}
你可以将上述代码保存为一个名为 “grass.c” 的文件，并使用C编译器进行编译和运行。在输入牧场地图的行数、列数以及每个位置的字符后，程序将计算出草丛的数量并输出。
在主函数中，我们首先读取牧场地图的行数 rows 和列数 cols。然后，定义一个字符数组 field 用于存储牧场地图的每个位置的字符。
接下来，我们使用两个嵌套的循环来读取每个位置的字符，并将其存储在 field 数组中。
然后，我们调用 countGrasslands 函数来计算草丛的数量。该函数使用一个二维数组 visited 来记录位置是否被访问过。在遍历地图的过程中，如果遇到一个未被访问过的草丛位置，我们将计数增加，并将与该位置相邻的草丛位置标记为已访问。
最后，我们输出计数结果。
请注意，这个解决方案假设输入是有效的，并且满足题目要求。如果输入超出限制范围，可能会导致输出错误。
第5题：字符串中最长的连续出现的字符
求一个字符串中最长的连续出现的字符，输出该字符及其出现次数。字符串中无空白字符(空格、回车和tab)，如果这样的字符不止一个，则输出出现最早的字符。
时间限制：1000
内存限制：65536
输入
一行，一个不包含空白字符的字符串，字符串长度小于200。
输出
一行，输出最长的连续出现的字符及其最长的连续出现次数，中间以一个空格分开。
样例输入
aaaaadbbbbbcccccccdddddddddd
样例输出
d 10
以下是解决该问题的C语言代码：
#include <stdio.h>
#include <string.h>
void findLongestConsecutiveChar(char str[]) {
int len = strlen(str);
int maxCount = 0;
char maxChar = str[0];
int currentCount = 1;
for (int i = 1; i < len; i++) {
if (str[i] == str[i-1]) {
currentCount++;
} else {
if (currentCount > maxCount) {
maxCount = currentCount;
maxChar = str[i-1];
}
currentCount = 1;
}
}
if (currentCount > maxCount) {
maxCount = currentCount;
maxChar = str[len-1];
}
printf("%c %d\n", maxChar, maxCount);
}
int main() {
char str[201];
scanf("%s", str);
findLongestConsecutiveChar(str);
return 0;
}
你可以将上述代码保存为一个名为 “longest.c” 的文件，并使用C编译器进行编译和运行。在输入字符串后，程序将计算出最长的连续出现的字符及其出现次数，并进行输出。
在主函数中，我们首先定义一个字符数组 str，用于存储输入的字符串。
接下来，我们调用 findLongestConsecutiveChar 函数来查找最长的连续出现的字符。该函数使用一个循环遍历字符串中的字符，并维护两个变量：maxCount 表示目前找到的最长连续出现次数，maxChar 表示对应的字符。我们还使用一个变量 currentCount 来记录当前字符的连续出现次数。
在遍历字符串的过程中，我们比较当前字符与前一个字符是否相同。如果相同，说明当前字符与前一个字符连续出现，将 currentCount 加1。如果不相同，说明当前字符打破了连续出现的序列，我们将比较当前的 currentCount 与 maxCount 的大小，如果 currentCount 大于 maxCount，则更新 maxCount 和 maxChar。然后，将 currentCount 重新置为1，以便开始计算下一个字符的连续出现次数。
最后，我们还需要在循环结束后再次比较 currentCount 与 maxCount，以处理最后一个字符连续出现的情况。
最终，我们输出 maxChar 和 maxCount。
请注意，这个解决方案假设输入是有效的，并且满足题目要求。如果输入超出限制范围，可能会导致输出错误。
