在这里插入图片描述

第1题：余数相同问题

已知三个正整数 a，b，c。
现有一个大于1的整数x，将其作为除数分别除a，b，c，得到的余数相同。
请问满足上述条件的x的最小值是多少?
数据保证x有解。
输入
一行，三个不大于1000000的正整数a，b，c，两个整数之间用一个空格隔开。
输出
一个整数，即满足条件的x的最小值。
样例输入
300 262 205
样例输出
19

这个问题可以通过遍历可能的除数 x 的方式来解决。我们可以从 2 开始逐个尝试，直到找到一个满足条件的 x 为止。

具体的解题思路如下：

（1）输入三个正整数 a，b，c。

（2）从 2 开始遍历除数 x。

（3）对于每个 x，计算 a、b、c 分别除以 x 的余数。

（4）如果三个余数相等，则输出 x，并结束程序。

（5）如果遍历完所有可能的 x 值都没有找到满足条件的 x，根据题目要求，这种情况是不会发生的。

下面是使用 C 语言实现的代码：

#include <stdio.h>

int main() {
    int a, b, c;
    scanf("%d %d %d", &a, &b, &c);

    int x = 2; // 从 2 开始尝试除数 x
    while (1) {
        int remainder_a = a % x;
        int remainder_b = b % x;
        int remainder_c = c % x;

        if (remainder_a == remainder_b && remainder_b == remainder_c) {
            printf("%d\n", x);
            break;
        }

        x++;
    }

    return 0;
}

你可以将这段代码保存为一个名为 remainder.c 的文件，然后使用 C 编译器进行编译并运行。输入三个正整数，程序将输出满足条件的 x 的最小值。

第2题：生成括号

生成括号
Paul是一名数学专业的同学，在课余选修了C++编程课，现在他能够自己写程序判断判断一个给定的由’(‘和’)'组成的字符串是否是正确匹配的。可是他不满足于此，想反其道而行之，设计一个程序，能够生成所有合法的括号组合，请你帮助他解决这个问题。
时间限制：1000
内存限制：65536
输入
输入只有一行N，代表生成括号的对数(1 ≤ N ≤ 10)。
输出
输出所有可能的并且有效的括号组合，按照字典序进行排列，每个组合占一行。
样例输入
3
样例输出
((()))
(()())
(())()
()(())
()()()

这个问题可以使用递归的方法来解决。基本思路是，对于每个位置，我们可以选择放置左括号 “(” 或右括号 “)”，但需要满足以下两个条件：

（1）左括号的数量不能超过 N。

（2）右括号的数量不能超过左括号的数量。

下面是使用 C 语言实现的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void generateParentheses(char* current, int leftCount, int rightCount, int N) {
    // 如果左括号和右括号的数量都达到了 N，说明已经生成了一组合法的括号组合
    if (leftCount == N && rightCount == N) {
        printf("%s\n", current);
        return;
    }

    // 如果左括号的数量小于 N，可以选择放置左括号
    if (leftCount < N) {
        current[leftCount + rightCount] = '(';
        generateParentheses(current, leftCount + 1, rightCount, N);
    }

    // 如果右括号的数量小于左括号的数量，可以选择放置右括号
    if (rightCount < leftCount) {
        current[leftCount + rightCount] = ')';
        generateParentheses(current, leftCount, rightCount + 1, N);
    }
}

int main() {
    int N;
    scanf("%d", &N);

    // 创建一个字符数组用于存储括号组合
    char* current = (char*)malloc(sizeof(char) * (2 * N + 1));
    memset(current, 0, sizeof(char) * (2 * N + 1));

    generateParentheses(current, 0, 0, N);

    free(current);

    return 0;
}

你可以将这段代码保存为一个名为 generate_parentheses.c 的文件，然后使用 C 编译器进行编译并运行。输入一个整数 N，程序将输出所有可能的并且有效的括号组合，按照字典序进行排列，每个组合占一行。

第3题：课程冲突

小 A 修了 n 门课程, 第 i 门课程是从第 ai 天一直上到第 bi 天。
定义两门课程的冲突程度为 : 有几天是这两门课程都要上的。
例如 a1=1,b1=3,a2=2,b2=4 时, 这两门课的冲突程度为 2。
现在你需要求的是这 n 门课中冲突程度最大的两门课的冲突程度。
时间限制：1000
内存限制：65536
输入
第一行一个正整数 n 表示课程数量。接下来 n 行,每行两个正整数 ai,bi。 2 ≤ n≤ 1000, 1 ≤ ai ≤ bi ≤ 1000。
输出
输出一个整数表示最大的冲突程度
样例输入
3
1 3
2 4
5 5
样例输出
2

这个问题可以通过遍历所有课程的组合，并计算它们的冲突程度来解决。对于每对课程，我们可以比较它们的上课时间，找出它们的重叠天数，并更新最大的冲突程度。

下面是使用 C 语言实现的代码：

#include <stdio.h>

int max(int a, int b) {
    return (a > b) ? a : b;
}

int main() {
    int n;
    scanf("%d", &n);

    int maxConflict = 0;

    // 读取每门课程的上课时间并计算冲突程度
    for (int i = 0; i < n; i++) {
        int ai, bi;
        scanf("%d %d", &ai, &bi);

        // 遍历已经计算过的课程，计算冲突程度
        for (int j = 0; j < i; j++) {
            int aj, bj;
            scanf("%d %d", &aj, &bj);

            int conflict = max(0, min(bi, bj) - max(ai, aj) + 1);
            maxConflict = max(maxConflict, conflict);
        }
    }

    printf("%d\n", maxConflict);

    return 0;
}

你可以将这段代码保存为一个名为 course_conflict.c 的文件，然后使用 C 编译器进行编译并运行。输入课程数量和每门课程的上课时间，程序将输出最大的冲突程度。

第4题：广义格雷码

在一组数的编码中，若任意两个相邻(首尾也视为相邻)的代码只有一位二进制数不同，则称这种编码为格雷码。如四位格雷码：
0000、0001、0011、0010、0110、0111、0101、0100、1100、1101、1111、1110、1010、1011、1001、1000
现在将格雷码扩展至其他进制，仍然是相邻两个数只能有一位不同。输入两个正整数n,m分别表示长度和进制，每行输出一个n位m进制数，输出任意一种编码即可。(提示：putchar输出效率更高)
时间限制：1000
内存限制：65536
输入
一行，两个整数n,m。其中 2 ≤ n ≤ 12 ,2 ≤ m ≤ 10 且mn ≤ 500000
输出
任意一种编码方案，每个编码一行。相邻两个编码相差一位。第一个编码和最后一个编码算相邻
样例输入
2 3
样例输出
00
10
20
21
01
11
12
22
02

这个问题可以使用递归的方式来生成广义格雷码。基本思路是，对于长度为 n 的广义格雷码，可以通过将长度为 n-1 的广义格雷码进行扩展得到。

具体的解题思路如下：

（1）输入两个整数 n 和 m。

（2）如果 n 等于 1，那么只有 m 个可能的编码，依次输出即可。

（3）否则，递归生成长度为 n-1 的广义格雷码。

（4）将长度为 n-1 的广义格雷码依次扩展为长度为 n 的广义格雷码。对于扩展的过程，我们需要在每个编码前面加上一个新的数字，范围从 0 到 m-1。

（5）输出生成的广义格雷码。

下面是使用 C 语言实现的代码：

#include <stdio.h>

void generateGrayCode(int n, int m) {
    if (n == 1) {
        for (int i = 0; i < m; i++) {
            putchar('0' + i);
            putchar('\n');
        }
        return;
    }

    generateGrayCode(n - 1, m);

    for (int i = 0; i < m; i++) {
        for (int j = n - 2; j >= 0; j--) {
            putchar('0' + (i / (1 << j)) % m);
        }
        putchar('0' + i);
        putchar('\n');
    }
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);

    generateGrayCode(n, m);

    return 0;
}

你可以将这段代码保存为一个名为 generalized_gray_code.c 的文件，然后使用 C 编译器进行编译并运行。输入两个整数 n 和 m，程序将输出任意一种长度为 n 的 m 进制广义格雷码方案，每个编码占一行。相邻两个编码相差一位，第一个编码和最后一个编码也算相邻。

第5题：菲波那契数列

菲波那契数列是指这样的数列: 数列的第一个和第二个数都为1，接下来每个数都等于前面2个数之和。给出一个正整数a，要求菲波那契数列中第a个数对10000取模的结果是多少。
时间限制：1000
内存限制：65536
输入
第1行是测试数据的组数n，后面跟着n行输入。每组测试数据占1行，包括一个正整数a(1 <= a <= 1000000)。
输出
n行，每行输出对应一个输入。输出应是一个正整数，为菲波那契数列中第a个数对10000取模得到的结果。
样例输入
4
5
2
19
1
样例输出
5
1
181
1

在这个问题中，我们需要计算菲波那契数列中第 a 个数对 10000 取模的结果。为了避免计算过程中的溢出，我们可以使用循环来逐步计算菲波那契数列，并在每一步都对 10000 取模。

下面是使用 C 语言实现的代码：

#include <stdio.h>

int fibonacciModulo(int a) {
    int prev = 0;
    int current = 1;

    for (int i = 2; i <= a; i++) {
        int temp = current;
        current = (prev + current) % 10000;
        prev = temp;
    }

    return current;
}

int main() {
    int n;
    scanf("%d", &n);

    for (int i = 0; i < n; i++) {
        int a;
        scanf("%d", &a);

        int result = fibonacciModulo(a);
        printf("%d\n", result);
    }

    return 0;
}