在这里插入图片描述

第1题：数字放大

给定一个整数序列以及放大倍数x，将序列中每个整数放大x倍后输出。
时间限制：1000
内存限制：65536
输入
包含三行：第一行为N，表示整数序列的长度(N ≤ 100); 第二行为N个整数(不超过整型范围)，整数之间以一个空格分开; 第三行包含一个整数(不超过整型范围)，为指定的整数x。
输出
N个整数，为原序列放大之后的序列，整数之间以一个空格分开。
样例输入
3
1 5 7
2
样例输出
2 10 14
提示
注意答案的数据范围

以下是使用C语言编写的解决方案，用于将给定整数序列中的每个整数放大x倍后输出：

#include <stdio.h>

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

    int sequence[N];
    for (int i = 0; i < N; i++) {
        scanf("%d", &sequence[i]);
    }

    int x;
    scanf("%d", &x);

    for (int i = 0; i < N; i++) {
        printf("%d ", sequence[i] * x);
    }
    printf("\n");

    return 0;
}

在此解决方案中，我们首先定义一个变量N，用于存储整数序列的长度。

然后，我们使用scanf函数读取N的值。

接下来，我们定义一个整数数组sequence，大小为N，用于存储整数序列。

使用循环结构，我们遍历整数序列，并使用scanf函数将每个整数读取到sequence数组中。

然后，我们定义一个变量x，用于存储放大倍数。

再次使用scanf函数，我们读取x的值。

接下来，使用循环结构，我们遍历整数序列，并将每个整数乘以x，然后使用printf函数输出结果。

最后，我们使用printf函数输出换行符，以便将结果打印在一行。

编译并运行上述代码，根据给定的输入示例，将会输出"2 10 14"，表示原序列放大后的序列。

第2题：统一文件名

小A在命名文件的时候经常不注意大小写，格式比较混乱。现要求你写一个程序将目录下的文件统一规范的格式，即文件名的第一个字符如果是字母要大写，其他字母小写。如将Test、test整理成Test。
时间限制：1000
内存限制：65536
输入
第一行一个数字n，表示有n个文件名要统一，n不超过100。接下来n行，每行一个单词，长度不超过20，表示文件的名字。文件名由字母、数字和-组成。
输出
n行，每行一个单词，对应统一后的文件名。
样例输入
4
Test
data
2-TEST
problem-6
样例输出
Test
Data
2-test
Problem-6

以下是使用C语言编写的解决方案，用于将给定的文件名统一规范化格式：

#include <stdio.h>
#include <ctype.h>

void normalizeFilename(char *filename) {
    int length = strlen(filename);

    // 将第一个字符转换为大写
    if (isalpha(filename[0])) {
        filename[0] = toupper(filename[0]);
    }

    // 将其余字符转换为小写
    for (int i = 1; i < length; i++) {
        filename[i] = tolower(filename[i]);
    }
}

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

    char filenames[n][21];
    for (int i = 0; i < n; i++) {
        scanf("%s", filenames[i]);
        normalizeFilename(filenames[i]);
    }

    for (int i = 0; i < n; i++) {
        printf("%s\n", filenames[i]);
    }

    return 0;
}

在此解决方案中，我们首先定义一个函数normalizeFilename，用于将给定的文件名规范化为统一格式。

在函数中，我们首先获取文件名的长度。

然后，我们将文件名的第一个字符转换为大写，使用isalpha函数检查字符是否为字母，使用toupper函数将字符转换为大写。

接下来，我们使用循环结构，将文件名的其余字符转换为小写，使用tolower函数将字符转换为小写。

在main函数中，我们首先定义一个变量n，用于存储文件名的个数。

然后，使用scanf函数读取n的值。

接下来，我们定义一个二维字符数组filenames，大小为n行，每行最多可以存储20个字符的文件名。

使用循环结构，我们遍历每个文件名，并使用scanf函数将文件名读取到相应的行中。

接着，我们调用normalizeFilename函数，将每个文件名规范化为统一格式。

最后，使用循环结构，我们遍历每个文件名，并使用printf函数输出结果。每个文件名占一行。

编译并运行上述代码，根据给定的输入示例，将会输出统一规范化后的文件名。

第3题：内部元素之和

输入一个整数矩阵，计算位于矩阵内部的元素之和。所谓矩阵内部的元素，不在第一行和最后一行的元素以及第一列和最后一列的元素。
时间限制：1000
内存限制：65536
输入
第一行分别为矩阵的行数m和列数n(m < 100，n < 100)，两者之间以一个空格分开。接下来输入的m行数据中，每行包含n个整数(每个数大于等于0，小于1000)，整数之间以一个空格分开。
输出
输出对应矩阵的内部元素和
样例输入
3 3
3 4 1
3 7 1
2 0 1
样例输出
7

以下是使用C语言编写的解决方案，用于计算位于矩阵内部的元素之和：

#include <stdio.h>

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

    int matrix[m][n];
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &matrix[i][j]);
        }
    }

    int sum = 0;
    for (int i = 1; i < m - 1; i++) {
        for (int j = 1; j < n - 1; j++) {
            sum += matrix[i][j];
        }
    }

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

    return 0;
}

在此解决方案中，我们首先定义两个变量m和n，分别表示矩阵的行数和列数。

然后，使用scanf函数读取m和n的值。

接下来，我们定义一个二维整数数组matrix，大小为m行n列，用于存储矩阵。

使用两个嵌套的循环结构，我们遍历矩阵的每个元素，使用scanf函数将每个整数读取到相应的位置。

然后，我们定义一个变量sum，用于存储内部元素之和。初始值为0。

使用两个嵌套的循环结构，我们遍历位于矩阵内部的元素，即从第二行到倒数第二行，从第二列到倒数第二列。我们忽略了第一行、最后一行、第一列和最后一列的元素。

在每个内部元素的位置，我们将该元素的值累加到sum中。

最后，我们使用printf函数输出sum的值，表示矩阵内部元素之和。

编译并运行上述代码，根据给定的输入示例，将会输出"7"，表示矩阵内部元素之和为7。

第4题：整数排序

给定10个整数的序列，要求对其重新排序。排序要求:
1.奇数在前，偶数在后;
2.奇数按从大到小排序;
3.偶数按输入顺序逆序排序。
时间限制：1000
内存限制：65536
输入
输入一行，包含10个整数，彼此以一个空格分开，每个整数的范围是大于等于0，小于等于100。
输出
按照要求排序后输出一行，包含排序后的10个整数，数与数之间以一个空格分开。
样例输入
4 7 3 13 11 12 0 47 34 98
样例输出
47 13 11 7 3 98 34 0 12 4

以下是使用C语言编写的解决方案，用于对给定的10个整数进行排序：

#include <stdio.h>

void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void bubbleSort(int arr[], int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] < arr[j + 1]) {
                swap(&arr[j], &arr[j + 1]);
            }
        }
    }
}

void customSort(int arr[], int n) {
    int odd[n];
    int even[n];
    int oddCount = 0;
    int evenCount = 0;

    for (int i = 0; i < n; i++) {
        if (arr[i] % 2 == 0) {
            even[evenCount++] = arr[i];
        } else {
            odd[oddCount++] = arr[i];
        }
    }

    bubbleSort(odd, oddCount);

    for (int i = evenCount - 1; i >= 0; i--) {
        printf("%d ", even[i]);
    }

    for (int i = 0; i < oddCount; i++) {
        printf("%d ", odd[i]);
    }
}

int main() {
    int arr[10];
    for (int i = 0; i < 10; i++) {
        scanf("%d", &arr[i]);
    }

    customSort(arr, 10);

    return 0;
}

在此解决方案中，我们首先定义了一个函数swap，用于交换两个整数的值。

然后，我们定义了一个函数bubbleSort，用于对数组进行冒泡排序。

在bubbleSort函数中，我们使用两个嵌套的循环结构，逐个比较相邻的元素，并根据条件进行交换，从而将较大的元素移动到数组的前面。

接下来，我们定义了一个函数customSort，用于按照给定的排序要求对数组进行排序。

在customSort函数中，我们首先定义了两个辅助数组odd和even，用于存储奇数和偶数。

我们遍历原始数组，并根据奇偶性将元素分别存储到odd和even数组中。

然后，我们对odd数组进行冒泡排序，以满足要求的奇数排序要求。

接着，我们逆序遍历even数组，并按顺序输出其中的元素，以满足偶数的逆序排序要求。

最后，我们按顺序输出odd数组中的元素。

在main函数中，我们定义一个整数数组arr，用于存储输入的10个整数。

使用循环结构，我们读取输入的10个整数，并将它们存储到arr数组中。

然后，我们调用customSort函数，对数组进行排序和输出。

编译并运行上述代码，根据给定的输入示例，将会输出排序后的10个整数。

第5题：计算好数

若将一个正整数化为二进制数，在此二进制数中，我们将数字1的个数多于数字0的个数的这类二进制数称为好数。
例如：
(13)10 = (1101)2，其中1的个数为3，0的个数为1，则此数是好数;
(10)10 = (1010)2，其中1的个数为2，0的个数也为2，则此数不是好数;
(24)10 = (11000)2，其中1的个数为2，0的个数为3，则此数不是好数;
对于给定的N,写程序求出1～N之中(包括1与N)中的好数个数。
时间限制：1000
内存限制：65536
输入
一个整数，题目中的N(N ≤ 1000)
输出
一个整数，表示1～N之中(包括1与N)中的好数个数
样例输入
10
样例输出
5

以下是使用C语言编写的解决方案，用于计算1～N范围内的好数个数：

#include <stdio.h>

int isGoodNumber(int n) {
    int ones = 0;
    int zeros = 0;

    while (n > 0) {
        if (n % 2 == 1) {
            ones++;
        } else {
            zeros++;
        }
        n /= 2;
    }

    return ones > zeros;
}

int countGoodNumbers(int N) {
    int count = 0;

    for (int i = 1; i <= N; i++) {
        if (isGoodNumber(i)) {
            count++;
        }
    }

    return count;
}

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

    int result = countGoodNumbers(N);
    printf("%d\n", result);

    return 0;
}